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