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