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