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