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