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