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