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