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