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