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