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