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