#include <stdio.h>
#interface "Tree.h"


/* #include <assert.h> */

// Case1 
//
// 4(B)
//

__code rbTreeTest1_1(struct Tree* tree) {
  printf("Test1_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest1_2);
}

__code rbTreeTest1_1_stub(struct Context* context) {
  printf("Test1_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest1_1(context,tree);
}

__code rbTreeTest1_2(struct Tree* tree) {
  printf("Test1_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert1);
}

__code rbTreeTest1_2_stub(struct Context* context) {
  printf("Test1_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest1_2(context,tree);
}

__code assert1(struct Tree* tree) {
  printf("assert1\n");
  goto exit_code();
}

// Case2
// 
//   4(B)
//   /
// 2(R)
//

__code rbTreeTest2_1(struct Tree* tree) {
  printf("Test2_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest2_2);
}

__code rbTreeTest2_1_stub(struct Context* context) {
  printf("Test2_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest2_1(context,tree);
}

__code rbTreeTest2_2(struct Tree* tree) {
  printf("Test2_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 2;
  node->key = 2;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest2_3);
}

__code rbTreeTest2_2_stub(struct Context* context) {
  printf("Test2_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest2_2(context,tree);
}

__code rbTreeTest2_3(struct Tree* tree) {
  printf("Test2_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert2);
}

__code rbTreeTest2_3_stub(struct Context* context) {
  printf("Test2_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest2_3(context,tree);
}

__code assert2(struct Tree* tree) {
  printf("assert2\n");
  goto exit_code();
}

// Case3
// 
//   4(B)
//     \
//     6(R)
//

__code rbTreeTest3_1(struct Tree* tree) {
  printf("Test3_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest3_2);
}

__code rbTreeTest3_1_stub(struct Context* context) {
  printf("Test3_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest3_1(context,tree);
}

__code rbTreeTest3_2(struct Tree* tree) {
  printf("Test3_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 6;
  node->key = 6;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest3_3);
}

__code rbTreeTest3_2_stub(struct Context* context) {
  printf("Test3_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest3_2(context,tree);
}

__code rbTreeTest3_3(struct Tree* tree) {
  printf("Test3_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert3);
}

__code rbTreeTest3_3_stub(struct Context* context) {
  printf("Test3_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest3_3(context,tree);
}

__code assert3(struct Tree* tree) {
  printf("assert3\n");
  goto exit_code();
}

// Case4
// 
//   4(B)
//   / \
// 2(R) 6(R)
//

__code rbTreeTest4_1(struct Tree* tree) {
  printf("Test4_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest4_2);
}

__code rbTreeTest4_1_stub(struct Context* context) {
  printf("test4_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest4_1(context,tree);
}

__code rbTreeTest4_2(struct Tree* tree) {
  printf("Test4_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 2;
  node->key = 2;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest4_3);
}

__code rbTreeTest4_2_stub(struct Context* context) {
  printf("test4_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest4_2(context,tree);
}

__code rbTreeTest4_3(struct Tree* tree) {
  printf("Test4_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 6;
  node->key = 6;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest4_4);
}

__code rbTreeTest4_3_stub(struct Context* context) {
  printf("test4_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest4_3(context,tree);
}

__code rbTreeTest4_4(struct Tree* tree) {
  printf("test4_4\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert4);
}

__code rbTreeTest4_4_stub(struct Context* context) {
  printf("test4_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest4_4(context,tree);
}

__code assert4(struct Tree* tree) {
  printf("assert4\n");
  goto exit_code();
}

// Case5
// 
//     4(B)
//     / \
//   2(R) 6(R)
//   /
// 1(B)

__code rbTreeTest5_1(struct Tree* tree) {
  printf("Test5_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest5_2);
}

__code rbTreeTest5_1_stub(struct Context* context) {
  printf("Test5_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest5_1(context,tree);
}

__code rbTreeTest5_2(struct Tree* tree) {
  printf("Test5_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 2;
  node->key = 2;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest5_3);
}

__code rbTreeTest5_2_stub(struct Context* context) {
  printf("Test5_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest5_2(context,tree);
}

__code rbTreeTest5_3(struct Tree* tree) {
  printf("Test5_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 6;
  node->key = 6;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest5_4);
}

__code rbTreeTest5_3_stub(struct Context* context) {
  printf("Test5_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest5_3(context,tree);
}

__code rbTreeTest5_4(struct Tree* tree) {
  printf("Test5_4\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 1;
  node->key = 1;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest5_5);
}

__code rbTreeTest5_4_stub(struct Context* context) {
  printf("Test5_4_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest5_4(context,tree);
}

__code rbTreeTest5_5(struct Tree* tree) {
  printf("Test5_5\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert5);
}

__code rbTreeTest5_5_stub(struct Context* context) {
  printf("Test5_5_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest5_5(context,tree);
}

__code assert5(struct Tree* tree) {
  printf("assert5\n");
  goto exit_code();
}

// Case6
// 
//     4(B)
//     / \
//   2(R) 6(R)
//         \
//          7(B)

__code rbTreeTest6_1(struct Tree* tree) {
  printf("Test6_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest6_2);
}

__code rbTreeTest6_1_stub(struct Context* context) {
  printf("Test6_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest6_1(context,tree);
}

__code rbTreeTest6_2(struct Tree* tree) {
  printf("Test6_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 2;
  node->key = 2;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest6_3);
}

__code rbTreeTest6_2_stub(struct Context* context) {
  printf("Test6_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest6_2(context,tree);
}

__code rbTreeTest6_3(struct Tree* tree) {
  printf("Test6_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 6;
  node->key = 6;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest6_4);
}

__code rbTreeTest6_3_stub(struct Context* context) {
  printf("Test6_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest6_3(context,tree);
}

__code rbTreeTest6_4(struct Tree* tree) {
  printf("Test6_4\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 7;
  node->key = 7;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest6_5);
}

__code rbTreeTest6_4_stub(struct Context* context) {
  printf("Test6_4_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest6_4(context,tree);
}

__code rbTreeTest6_5(struct Tree* tree) {
  printf("Test6_5\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert6);
}

__code rbTreeTest6_5_stub(struct Context* context) {
  printf("Test6_5_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest6_5(context,tree);
}

__code assert6(struct Tree* tree) {
  printf("assert6\n");
  goto exit_code();
}

// Case7
// 
//     4(B)
//     / \
//   2(R) 6(R)
//     \
//      3(B)

__code rbTreeTest7_1(struct Tree* tree) {
  printf("Test7_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest7_2);
}

__code rbTreeTest7_1_stub(struct Context* context) {
  printf("Test7_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest7_1(context,tree);
}

__code rbTreeTest7_2(struct Tree* tree) {
  printf("Test7_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 2;
  node->key = 2;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest7_3);
}

__code rbTreeTest7_2_stub(struct Context* context) {
  printf("Test7_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest7_2(context,tree);
}

__code rbTreeTest7_3(struct Tree* tree) {
  printf("Test7_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 6;
  node->key = 6;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest7_4);
}

__code rbTreeTest7_3_stub(struct Context* context) {
  printf("Test7_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest7_3(context,tree);
}

__code rbTreeTest7_4(struct Tree* tree) {
  printf("Test7_4\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 3;
  node->key = 3;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest7_5);
}

__code rbTreeTest7_4_stub(struct Context* context) {
  printf("Test7_4_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest7_4(context,tree);
}

__code rbTreeTest7_5(struct Tree* tree) {
  printf("Test7_5\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert7);
}

__code rbTreeTest7_5_stub(struct Context* context) {
  printf("Test7_5_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest7_5(context,tree);
}

__code assert7(struct Tree* tree) {
  printf("assert7\n");
  goto exit_code();
}

// Case8
// 
//      4(B)
//     /    \
//   2(B)   6(B)
//           /
//          5(R)

__code rbTreeTest8_1(struct Tree* tree) {
  printf("Test8_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest8_2);
}

__code rbTreeTest8_1_stub(struct Context* context) {
  printf("Test8_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest8_1(context,tree);
}

__code rbTreeTest8_2(struct Tree* tree) {
  printf("Test8_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 2;
  node->key = 2;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest8_3);
}

__code rbTreeTest8_2_stub(struct Context* context) {
  printf("Test8_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest8_2(context,tree);
}

__code rbTreeTest8_3(struct Tree* tree) {
  printf("Test8_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 6;
  node->key = 6;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest8_4);
}

__code rbTreeTest8_3_stub(struct Context* context) {
  printf("Test8_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest8_3(context,tree);
}

__code rbTreeTest8_4(struct Tree* tree) {
  printf("Test8_4\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 5;
  node->key = 5;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest8_5);
}

__code rbTreeTest8_4_stub(struct Context* context) {
  printf("Test8_4_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest8_4(context,tree);
}

__code rbTreeTest8_5(struct Tree* tree) {
  printf("Test8_5\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert8);
}

__code rbTreeTest8_5_stub(struct Context* context) {
  printf("Test8_5_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest8_5(context,tree);
}

__code assert8(struct Tree* tree) {
  printf("assert8\n");
  goto exit_code();
}

// Case9
// 
//      4(B)
//     /    \
//   2(B)   6(B)
//   / \
// 1(R)3(R)

__code rbTreeTest9_1(struct Tree* tree) {
  printf("Test9_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest9_2);
}

__code rbTreeTest9_1_stub(struct Context* context) {
  printf("Test9_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest9_1(context,tree);
}

__code rbTreeTest9_2(struct Tree* tree) {
  printf("Test9_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 2;
  node->key = 2;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest9_3);
}

__code rbTreeTest9_2_stub(struct Context* context) {
  printf("Test9_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest9_2(context,tree);
}

__code rbTreeTest9_3(struct Tree* tree) {
  printf("Test9_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 6;
  node->key = 6;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest9_4);
}

__code rbTreeTest9_3_stub(struct Context* context) {
  printf("Test9_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest9_3(context,tree);
}

__code rbTreeTest9_4(struct Tree* tree) {
  printf("Test9_4\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 1;
  node->key = 1;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest9_5);
}

__code rbTreeTest9_4_stub(struct Context* context) {
  printf("Test9_4_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest9_4(context,tree);
}

__code rbTreeTest9_5(struct Tree* tree) {
  printf("Test9_5\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 3;
  node->key = 3;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest9_6);
}

__code rbTreeTest9_5_stub(struct Context* context) {
  printf("Test9_5_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest9_5(context,tree);
}

__code rbTreeTest9_6(struct Tree* tree) {
  printf("Test9_6\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert9);
}

__code rbTreeTest9_6_stub(struct Context* context) {
  printf("Test9_6_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest9_6(context,tree);
}

__code assert9(struct Tree* tree) {
  printf("assert9\n");
  goto exit_code();
}

// Case10
// 
//      4(B)
//     /    \
//   2(B)   6(B)
//           / \
//          5(R)7(R)

__code rbTreeTest10_1(struct Tree* tree) {
  printf("Test10_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest10_2);
}

__code rbTreeTest10_1_stub(struct Context* context) {
  printf("test10_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest10_1(context,tree);
}

__code rbTreeTest10_2(struct Tree* tree) {
  printf("Test10_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 2;
  node->key = 2;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest10_3);
}

__code rbTreeTest10_2_stub(struct Context* context) {
  printf("test10_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest10_2(context,tree);
}

__code rbTreeTest10_3(struct Tree* tree) {
  printf("Test10_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 6;
  node->key = 6;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest10_4);
}

__code rbTreeTest10_3_stub(struct Context* context) {
  printf("test10_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest10_3(context,tree);
}

__code rbTreeTest10_4(struct Tree* tree) {
  printf("Test10_4\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 5;
  node->key = 5;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest10_5);
}

__code rbTreeTest10_4_stub(struct Context* context) {
  printf("test10_4_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest10_4(context,tree);
}

__code rbTreeTest10_5(struct Tree* tree) {
  printf("Test10_5\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 7;
  node->key = 7;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest10_6);
}

__code rbTreeTest10_5_stub(struct Context* context) {
  printf("test10_5_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest10_5(context,tree);
}

__code rbTreeTest10_6(struct Tree* tree) {
  printf("test10_8\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert10);
}

__code rbTreeTest10_6_stub(struct Context* context) {
  printf("test10_6_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest10_6(context,tree);
}

__code assert10(struct Tree* tree) {
  printf("assert10\n");
  goto exit_code();
}

// Case11
// 
//      4(B)
//     /    \
//   2(B)   6(B)
//   / \     / \
// 1(R)3(R) 5(R)7(R)

__code rbTreeTest11_1(struct Tree* tree) {
  printf("Test11_1\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 4;
  node->key = 4;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest11_2);
}

__code rbTreeTest11_1_stub(struct Context* context) {
  printf("test11_1_stub\n");
  Tree* tree = createRedBlackTree(context);
  goto rbTreeTest11_1(context,tree);
}

__code rbTreeTest11_2(struct Tree* tree) {
  printf("Test11_2\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 2;
  node->key = 2;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest11_3);
}

__code rbTreeTest11_2_stub(struct Context* context) {
  printf("test11_2_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest11_2(context,tree);
}

__code rbTreeTest11_3(struct Tree* tree) {
  printf("Test11_3\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 6;
  node->key = 6;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest11_4);
}

__code rbTreeTest11_3_stub(struct Context* context) {
  printf("test11_3_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest11_3(context,tree);
}

__code rbTreeTest11_4(struct Tree* tree) {
  printf("Test11_4\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 1;
  node->key = 1;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest11_5);
}

__code rbTreeTest11_4_stub(struct Context* context) {
  printf("test11_4_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest11_4(context,tree);
}

__code rbTreeTest11_5(struct Tree* tree) {
  printf("Test11_5\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 3;
  node->key = 3;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest11_6);
}

__code rbTreeTest11_5_stub(struct Context* context) {
  printf("test11_5_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest11_5(context,tree);
}

__code rbTreeTest11_6(struct Tree* tree) {
  printf("Test11_6\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 5;
  node->key = 5;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest11_7);
}

__code rbTreeTest11_6_stub(struct Context* context) {
  printf("test11_6_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest11_6(context,tree);
}

__code rbTreeTest11_7(struct Tree* tree) {
  printf("Test11_7\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  ((Integer*)node->value)->value = 7;
  node->key = 7;
  printf("value->%d,key->%d\n",((Integer*)node->value)->value,node->key);
  goto tree->put(node, rbTreeTest11_8);
}

__code rbTreeTest11_7_stub(struct Context* context) {
  printf("test11_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest11_7(context,tree);
}

__code rbTreeTest11_8(struct Tree* tree) {
  printf("test11_8\n");
  Node* node = new Node();
  node->value = (union Data*)new Integer();
  goto tree->copy(assert11);
}

__code rbTreeTest11_8_stub(struct Context* context) {
  printf("test11_8_stub\n");
  Tree* tree = (struct Tree*)Gearef(context, Tree)->tree;
  goto rbTreeTest11_8(context,tree);
}

__code assert11(struct Tree* tree) {
  printf("assert11\n");
  goto exit_code();
}

int main(int argc, char const* argv[]) {
  printf("test_main\n");
  goto rbTreeTest1_1();
  // goto rbTreeTest2_1();
  // goto rbTreeTest3_1();
  // goto rbTreeTest4_1();
  // goto rbTreeTest5_1();
  // goto rbTreeTest6_1();
  // goto rbTreeTest7_1();
  // goto rbTreeTest8_1();
  // goto rbTreeTest9_1();
  // goto rbTreeTest10_1();
  // goto rbTreeTest11_1();
}