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