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