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