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