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