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