From dd7d30017c97f0f976cc7b3dc6461cd20da26291 Mon Sep 17 00:00:00 2001
From: Benjamin Wang <wachao@vmware.com>
Date: Wed, 21 Sep 2022 15:53:44 +0800
Subject: [PATCH] Bump go 1.19: revert the change to pkg/adt/interval_tree.go

Some comments in the file are formatted automatically into ugly style,
because the hierarchical structure is missing. After removing the
leading numbers in the comments, `go fmt` will not format the comments
anymore.

Signed-off-by: Benjamin Wang <wachao@vmware.com>
---
 pkg/adt/interval_tree.go | 328 +++++++++++++++++++--------------------
 1 file changed, 164 insertions(+), 164 deletions(-)

diff --git a/pkg/adt/interval_tree.go b/pkg/adt/interval_tree.go
index 63be100a0..bfd13fb73 100644
--- a/pkg/adt/interval_tree.go
+++ b/pkg/adt/interval_tree.go
@@ -241,34 +241,34 @@ type intervalTree struct {
 //
 // "Introduction to Algorithms" (Cormen et al, 3rd ed.), chapter 13.4, p324
 //
-//	 0. RB-DELETE(T, z)
-//	 1.
-//	 2. y = z
-//	 3. y-original-color = y.color
-//	 4.
-//	 5. if z.left == T.nil
-//	 6. 	x = z.right
-//	 7. 	RB-TRANSPLANT(T, z, z.right)
-//	 8. else if z.right == T.nil
-//	 9. 	x = z.left
-//	10. 	RB-TRANSPLANT(T, z, z.left)
-//	11. else
-//	12. 	y = TREE-MINIMUM(z.right)
-//	13. 	y-original-color = y.color
-//	14. 	x = y.right
-//	15. 	if y.p == z
-//	16. 		x.p = y
-//	17. 	else
-//	18. 		RB-TRANSPLANT(T, y, y.right)
-//	19. 		y.right = z.right
-//	20. 		y.right.p = y
-//	21. 	RB-TRANSPLANT(T, z, y)
-//	22. 	y.left = z.left
-//	23. 	y.left.p = y
-//	24. 	y.color = z.color
-//	25.
-//	26. if y-original-color == BLACK
-//	27. 	RB-DELETE-FIXUP(T, x)
+//	  RB-DELETE(T, z)
+//
+//	  y = z
+//	  y-original-color = y.color
+//
+//	  if z.left == T.nil
+//	  	x = z.right
+//	  	RB-TRANSPLANT(T, z, z.right)
+//	  else if z.right == T.nil
+//	  	x = z.left
+//	 	RB-TRANSPLANT(T, z, z.left)
+//	  else
+//	 	y = TREE-MINIMUM(z.right)
+//	 	y-original-color = y.color
+//	 	x = y.right
+//	 	if y.p == z
+//	 		x.p = y
+//	 	else
+//	 		RB-TRANSPLANT(T, y, y.right)
+//	 		y.right = z.right
+//	 		y.right.p = y
+//	 	RB-TRANSPLANT(T, z, y)
+//	 	y.left = z.left
+//	 	y.left.p = y
+//	 	y.color = z.color
+//
+//	  if y-original-color == BLACK
+//	  	RB-DELETE-FIXUP(T, x)
 
 // Delete removes the node with the given interval from the tree, returning
 // true if a node is in fact removed.
@@ -317,47 +317,47 @@ func (ivt *intervalTree) Delete(ivl Interval) bool {
 
 // "Introduction to Algorithms" (Cormen et al, 3rd ed.), chapter 13.4, p326
 //
-//  0. RB-DELETE-FIXUP(T, z)
-//     1.
-//  2. while x ≠ T.root and x.color == BLACK
-//  3. if x == x.p.left
-//  4. w = x.p.right
-//  5. if w.color == RED
-//  6. w.color = BLACK
-//  7. x.p.color = RED
-//  8. LEFT-ROTATE(T, x, p)
-//  9. if w.left.color == BLACK and w.right.color == BLACK
-//  10. w.color = RED
-//  11. x = x.p
-//  12. else if w.right.color == BLACK
-//  13. w.left.color = BLACK
-//  14. w.color = RED
-//  15. RIGHT-ROTATE(T, w)
-//  16. w = w.p.right
-//  17. w.color = x.p.color
-//  18. x.p.color = BLACK
-//  19. LEFT-ROTATE(T, w.p)
-//  20. x = T.root
-//  21. else
-//  22. w = x.p.left
-//  23. if w.color == RED
-//  24. w.color = BLACK
-//  25. x.p.color = RED
-//  26. RIGHT-ROTATE(T, x, p)
-//  27. if w.right.color == BLACK and w.left.color == BLACK
-//  28. w.color = RED
-//  29. x = x.p
-//  30. else if w.left.color == BLACK
-//  31. w.right.color = BLACK
-//  32. w.color = RED
-//  33. LEFT-ROTATE(T, w)
-//  34. w = w.p.left
-//  35. w.color = x.p.color
-//  36. x.p.color = BLACK
-//  37. RIGHT-ROTATE(T, w.p)
-//  38. x = T.root
-//     39.
-//  40. x.color = BLACK
+//	RB-DELETE-FIXUP(T, z)
+//
+//	while x ≠ T.root and x.color == BLACK
+//		if x == x.p.left
+//			w = x.p.right
+//			if w.color == RED
+//				w.color = BLACK
+//				x.p.color = RED
+//				LEFT-ROTATE(T, x, p)
+//			if w.left.color == BLACK and w.right.color == BLACK
+//				w.color = RED
+//				x = x.p
+//			else if w.right.color == BLACK
+//					w.left.color = BLACK
+//					w.color = RED
+//					RIGHT-ROTATE(T, w)
+//					w = w.p.right
+//				w.color = x.p.color
+//				x.p.color = BLACK
+//				LEFT-ROTATE(T, w.p)
+//				x = T.root
+//		else
+//			w = x.p.left
+//			if w.color == RED
+//				w.color = BLACK
+//				x.p.color = RED
+//				RIGHT-ROTATE(T, x, p)
+//			if w.right.color == BLACK and w.left.color == BLACK
+//				w.color = RED
+//				x = x.p
+//			else if w.left.color == BLACK
+//					w.right.color = BLACK
+//					w.color = RED
+//					LEFT-ROTATE(T, w)
+//					w = w.p.left
+//				w.color = x.p.color
+//				x.p.color = BLACK
+//				RIGHT-ROTATE(T, w.p)
+//				x = T.root
+//
+//	x.color = BLACK
 func (ivt *intervalTree) deleteFixup(x *intervalNode) {
 	for x != ivt.root && x.color(ivt.sentinel) == black {
 		if x == x.parent.left { // line 3-20
@@ -438,32 +438,32 @@ func (ivt *intervalTree) createIntervalNode(ivl Interval, val interface{}) *inte
 //
 // "Introduction to Algorithms" (Cormen et al, 3rd ed.), chapter 13.3, p315
 //
-//	 0. RB-INSERT(T, z)
-//	 1.
-//	 2. y = T.nil
-//	 3. x = T.root
-//	 4.
-//	 5. while x ≠ T.nil
-//	 6. 	y = x
-//	 7. 	if z.key < x.key
-//	 8. 		x = x.left
-//	 9. 	else
-//	10. 		x = x.right
-//	11.
-//	12. z.p = y
-//	13.
-//	14. if y == T.nil
-//	15. 	T.root = z
-//	16. else if z.key < y.key
-//	17. 	y.left = z
-//	18. else
-//	19. 	y.right = z
-//	20.
-//	21. z.left = T.nil
-//	22. z.right = T.nil
-//	23. z.color = RED
-//	24.
-//	25. RB-INSERT-FIXUP(T, z)
+//	 RB-INSERT(T, z)
+//
+//	 y = T.nil
+//	 x = T.root
+//
+//	 while x ≠ T.nil
+//	 	y = x
+//	 	if z.key < x.key
+//	 		x = x.left
+//	 	else
+//	 		x = x.right
+//
+//	 z.p = y
+//
+//	 if y == T.nil
+//	 	T.root = z
+//	 else if z.key < y.key
+//	 	y.left = z
+//	 else
+//	 	y.right = z
+//
+//	 z.left = T.nil
+//	 z.right = T.nil
+//	 z.color = RED
+//
+//	 RB-INSERT-FIXUP(T, z)
 
 // Insert adds a node with the given interval into the tree.
 func (ivt *intervalTree) Insert(ivl Interval, val interface{}) {
@@ -498,37 +498,37 @@ func (ivt *intervalTree) Insert(ivl Interval, val interface{}) {
 
 // "Introduction to Algorithms" (Cormen et al, 3rd ed.), chapter 13.3, p316
 //
-//  0. RB-INSERT-FIXUP(T, z)
-//     1.
-//  2. while z.p.color == RED
-//  3. if z.p == z.p.p.left
-//  4. y = z.p.p.right
-//  5. if y.color == RED
-//  6. z.p.color = BLACK
-//  7. y.color = BLACK
-//  8. z.p.p.color = RED
-//  9. z = z.p.p
-//  10. else if z == z.p.right
-//  11. z = z.p
-//  12. LEFT-ROTATE(T, z)
-//  13. z.p.color = BLACK
-//  14. z.p.p.color = RED
-//  15. RIGHT-ROTATE(T, z.p.p)
-//  16. else
-//  17. y = z.p.p.left
-//  18. if y.color == RED
-//  19. z.p.color = BLACK
-//  20. y.color = BLACK
-//  21. z.p.p.color = RED
-//  22. z = z.p.p
-//  23. else if z == z.p.right
-//  24. z = z.p
-//  25. RIGHT-ROTATE(T, z)
-//  26. z.p.color = BLACK
-//  27. z.p.p.color = RED
-//  28. LEFT-ROTATE(T, z.p.p)
-//     29.
-//  30. T.root.color = BLACK
+//	RB-INSERT-FIXUP(T, z)
+//
+//	while z.p.color == RED
+//		if z.p == z.p.p.left
+//			y = z.p.p.right
+//			if y.color == RED
+//				z.p.color = BLACK
+//				y.color = BLACK
+//				z.p.p.color = RED
+//				z = z.p.p
+//			else if z == z.p.right
+//					z = z.p
+//					LEFT-ROTATE(T, z)
+//				z.p.color = BLACK
+//				z.p.p.color = RED
+//				RIGHT-ROTATE(T, z.p.p)
+//		else
+//			y = z.p.p.left
+//			if y.color == RED
+//				z.p.color = BLACK
+//				y.color = BLACK
+//				z.p.p.color = RED
+//				z = z.p.p
+//			else if z == z.p.right
+//					z = z.p
+//					RIGHT-ROTATE(T, z)
+//				z.p.color = BLACK
+//				z.p.p.color = RED
+//				LEFT-ROTATE(T, z.p.p)
+//
+//	T.root.color = BLACK
 func (ivt *intervalTree) insertFixup(z *intervalNode) {
 	for z.parent.color(ivt.sentinel) == red {
 		if z.parent == z.parent.parent.left { // line 3-15
@@ -576,25 +576,25 @@ func (ivt *intervalTree) insertFixup(z *intervalNode) {
 //
 // "Introduction to Algorithms" (Cormen et al, 3rd ed.), chapter 13.2, p313
 //
-//  0. LEFT-ROTATE(T, x)
-//     1.
-//  2. y = x.right
-//  3. x.right = y.left
-//     4.
-//  5. if y.left ≠ T.nil
-//  6. y.left.p = x
-//     7.
-//  8. y.p = x.p
-//     9.
-//  10. if x.p == T.nil
-//  11. T.root = y
-//  12. else if x == x.p.left
-//  13. x.p.left = y
-//  14. else
-//  15. x.p.right = y
-//     16.
-//  17. y.left = x
-//  18. x.p = y
+//	LEFT-ROTATE(T, x)
+//
+//	y = x.right
+//	x.right = y.left
+//
+//	if y.left ≠ T.nil
+//		y.left.p = x
+//
+//	y.p = x.p
+//
+//	if x.p == T.nil
+//		T.root = y
+//	else if x == x.p.left
+//		x.p.left = y
+//	else
+//		x.p.right = y
+//
+//	y.left = x
+//	x.p = y
 func (ivt *intervalTree) rotateLeft(x *intervalNode) {
 	// rotateLeft x must have right child
 	if x.right == ivt.sentinel {
@@ -621,25 +621,25 @@ func (ivt *intervalTree) rotateLeft(x *intervalNode) {
 
 // rotateRight moves x so it is right of its left child
 //
-//  0. RIGHT-ROTATE(T, x)
-//     1.
-//  2. y = x.left
-//  3. x.left = y.right
-//     4.
-//  5. if y.right ≠ T.nil
-//  6. y.right.p = x
-//     7.
-//  8. y.p = x.p
-//     9.
-//  10. if x.p == T.nil
-//  11. T.root = y
-//  12. else if x == x.p.right
-//  13. x.p.right = y
-//  14. else
-//  15. x.p.left = y
-//     16.
-//  17. y.right = x
-//  18. x.p = y
+//	RIGHT-ROTATE(T, x)
+//
+//	y = x.left
+//	x.left = y.right
+//
+//	if y.right ≠ T.nil
+//		y.right.p = x
+//
+//	y.p = x.p
+//
+//	if x.p == T.nil
+//		T.root = y
+//	else if x == x.p.right
+//		x.p.right = y
+//	else
+//		x.p.left = y
+//
+//	y.right = x
+//	x.p = y
 func (ivt *intervalTree) rotateRight(x *intervalNode) {
 	// rotateRight x must have left child
 	if x.left == ivt.sentinel {