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