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