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