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