--- a/src/llrb/llrb.c	Tue Sep 15 15:21:50 2015 +0900
+++ b/src/llrb/llrb.c	Tue Oct 20 16:22:42 2015 +0900
@@ -1,97 +1,14 @@
 #include <stdio.h>
-#include <stdlib.h>
-#include <sys/time.h>
 
 #include "llrbContext.h"
-
 #include "origin_cs.h"
-
 #include "stack.h"
 
-#define NUM 100
-
-extern __code initLLRBContext(struct Context* context);
 extern void allocator(struct Context* context);
 extern void compare(struct Context* context, struct Tree* tree, int key1, int key2);
 
-/* 
-__code code1(Allocate allocate) {
-    allocate.size = sizeof(long);
-    allocate.next = Code2;
-    goto Allocate(allocate);
-}
-*/
-static double st_time;
-static double ed_time;
-static int num;
-static clock_t c1,c2;
-
-static stack_ptr pstack;
-static struct Node* pre;
-
-static double getTime() {
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return tv.tv_sec + (double)tv.tv_usec*1e-6;
-}
-
-void print_tree(struct Node* node, int n) {
-    if (node != 0) {
-        print_tree(node->left, n+1);
-        for (int i=0;i<n;i++)
-            printf("  ");
-        printf("key=%d depth=%d\t%p\n", node->key, n, node);
-        print_tree(node->right, n+1);
-    }
-}
-
-__code code1(struct Context* context, struct Allocate *allocate) {
-    allocate->size = sizeof(struct Count);
-    allocator(context);
-    goto meta(context, Code2);
-}
-
-__code code1_stub(struct Context* context) {
-    goto code1(context, &context->data[Allocate]->allocate);
-}
-
-
-/*
-__code code2(Allocate allocate, Count count) {
-    count.count = 0;
-    goto code3(count);
-}
-*/
-
-__code code2(struct Context* context, struct Count* count) {
-    count->i = 1;
-    goto meta(context, Code3);
-}
-
-__code code2_stub(struct Context* context) {
-    goto code2(context, &context->data[context->dataNum]->count);
-}
-
-__code code3(struct Context* context, struct Node* node, struct Count* count) {
-    if (count->i == num) {
-        goto meta(context, Code4);
-    }
-
-    context->next = Code3;
-    node->key = count->i;
-    node->value = count->i;
-    
-    count->i++;
-    goto meta(context, Put);
-}
-
-__code code3_stub(struct Context* context) {
-    goto code3(context, &context->data[Node]->node, &context->data[3]->count);
-}
-
-__code meta(struct Context* context, enum Code next) {
-    goto (context->code[next])(context);
-}
+extern int num;
+extern stack_ptr node_stack;
 
 __code put(struct Context* context, struct Tree* tree, struct Allocate* allocate) {
     allocate->size = sizeof(struct Node);
@@ -102,6 +19,7 @@
     } else {
         tree->current = tree->root;
         compare(context, tree, tree->current->key, context->data[Node]->node.key);
+
         goto meta(context, Replace);
     }
 }
@@ -111,13 +29,28 @@
 }
 
 __code replaceNode(struct Context* context, struct Tree* tree, struct Node* oldNode, struct Node* newNode, int result) {
-    stack_push(pstack, &newNode);
+    stack_push(node_stack, &newNode);
 
     *newNode = *oldNode;
 
     if (result == 0) {
-        stack_pop(pstack, &tree->current);
-        goto meta(context, RotateL);
+        stack_pop(node_stack, &tree->current);
+        newNode->value = context->data[Node]->node.value;
+
+        if (tree->current->right != 0)
+            if (tree->current->right->color == Red)
+                goto meta(context, RotateL);
+
+        if (tree->current->left != 0)
+            if (tree->current->left->left != 0)
+                if (tree->current->left->color == Red && tree->current->left->left->color == Red)
+                    goto meta(context, RotateR);
+        
+        if (tree->current->right != 0 && tree->current->left != 0)
+            if (tree->current->right->color == Red && tree->current->left->color == Red)
+                goto meta(context, ColorFlip);
+        
+        goto meta(context, FixUp);
     } else if (result == 1) {
         tree->current = oldNode->right;
         newNode->right = context->heap;
@@ -129,10 +62,11 @@
     allocator(context);
 
     if (tree->current == 0) {
-        stack_pop(pstack, &tree->current);
+        stack_pop(node_stack, &tree->current);
         goto meta(context, Insert);
     } else {
         compare(context, tree, tree->current->key, context->data[Node]->node.key);
+        
         goto meta(context, Replace);
     }
 }
@@ -148,64 +82,78 @@
     if (tree->root == 0) {
         newNode->color = Black;
         tree->root = newNode;
+        tree->current = 0;
         goto meta(context, context->next);
     }
 
-    goto meta(context, RotateL);
+    if (tree->current->right != 0)
+        if (tree->current->right->color == Red)
+            goto meta(context, RotateL);
+
+    
+    if (tree->current->left != 0)
+        if (tree->current->left->left != 0)
+            if (tree->current->left->color == Red && tree->current->left->left->color == Red)
+                goto meta(context, RotateR);
+            
+    if (tree->current->right != 0 && tree->current->left != 0)
+        if (tree->current->right->color == Red && tree->current->left->color == Red)
+            goto meta(context, ColorFlip);
+    
+    goto meta(context, FixUp);
 }
 
 __code insertNode_stub(struct Context* context) {
     goto insertNode(context, &context->data[Tree]->tree, &context->data[Node]->node, &context->data[context->dataNum]->node);
 }
 
-__code rotateLeft(struct Context* context, struct Node* node) {
-    if (node->right != 0) {
-        if (node->right->color == Red) {
-            struct Node* tmp = node->right;
-            node->right = tmp->left;
-            tmp->left = node;
-            tmp->color = tmp->left->color;
-            tmp->left->color = Red;
-            context->data[Tree]->tree.current = tmp;
-        }
-    }
+__code rotateLeft(struct Context* context, struct Node* node, struct Tree* tree) {
+    struct Node* tmp = node->right;
+    node->right = tmp->left;
+    tmp->left = node;
+    tmp->color = node->color;
+    node->color = Red;
+    tree->current = tmp;
     
-    goto meta(context, RotateR);
+    if (tree->current->left != 0)
+        if (tree->current->left->left != 0)
+            if (tree->current->left->color == Red && tree->current->left->left->color == Red)
+                goto meta(context, RotateR);
+
+    if (tree->current->right != 0 && tree->current->left != 0)
+        if (tree->current->right->color == Red && tree->current->left->color == Red)
+            goto meta(context, ColorFlip);
+    
+    goto meta(context, FixUp);
 }
     
 __code rotateLeft_stub(struct Context* context) {
-    goto rotateLeft(context, context->data[Tree]->tree.current);
+    goto rotateLeft(context, context->data[Tree]->tree.current, &context->data[Tree]->tree);
 }
 
-__code rotateRight(struct Context* context, struct Node* node) {
-    if (node->left != 0) {
-        if (node->left->left != 0) {
-            if (node->left->color == Red && node->left->left->color == Red) {
-                struct Node* tmp = node->left;
-                node->left = tmp->right;
-                tmp->right = node;
-                tmp->color = tmp->right->color;
-                tmp->right->color = Red;
-                context->data[Tree]->tree.current = tmp;
-            }
-        }
-    }
+__code rotateRight(struct Context* context, struct Node* node, struct Tree* tree) {
+    struct Node* tmp = node->left;
+    node->left = tmp->right;
+    tmp->right = node;
+    tmp->color = node->color;
+    node->color = Red;
+    context->data[Tree]->tree.current = tmp;
 
-    goto meta(context, ColorFlip);
+    if (tree->current->right != 0 && tree->current->left != 0)
+        if (tree->current->right->color == Red && tree->current->left->color == Red)
+            goto meta(context, ColorFlip);
+    
+    goto meta(context, FixUp);
 }
 
 __code rotateRight_stub(struct Context* context) {
-    goto rotateRight(context, context->data[Tree]->tree.current);
+    goto rotateRight(context, context->data[Tree]->tree.current, &context->data[Tree]->tree);
 }
 
 __code colorFlip(struct Context* context, struct Node* node) {
-    if (node->right != 0 && node->left != 0) {
-        if (node->right->color == Red && node->left->color == Red) {
-            node->color ^= 1;
-            node->left->color ^= 1;
-            node->right->color ^= 1;
-        }
-    }
+    node->color ^= 1;
+    node->left->color ^= 1;
+    node->right->color ^= 1;
     
     goto meta(context, FixUp);
 }
@@ -218,12 +166,14 @@
     node->key = newNode->key;
     tree->prev = newNode;
     
-    if (stack_pop(pstack, &tree->current) == 0) {
+    if (stack_pop(node_stack, &tree->current) == 0) {
         compare(context, tree, tree->current->key, node->key);
         goto meta(context, ChangeRef);
     }
     
+    newNode->color = Black;
     tree->root = newNode;
+    tree->current = 0;
     
     goto meta(context, context->next);
 }    
@@ -241,77 +191,276 @@
         perror("bad status");
     }
     
-    goto meta(context, RotateL);
+    if (tree->current->right != 0)
+        if (tree->current->right->color == Red)
+            goto meta(context, RotateL);
+
+    if (tree->current->left != 0)
+        if (tree->current->left->left != 0)
+            if (tree->current->left->color == Red && tree->current->left->left->color == Red)
+                goto meta(context, RotateR);
+            
+    if (tree->current->right != 0 && tree->current->left != 0)
+        if (tree->current->right->color == Red && tree->current->left->color == Red)
+            goto meta(context, ColorFlip);
+
+    goto meta(context, FixUp);
 }
 
 __code changeReference_stub(struct Context* context) {
     goto changeReference(context, &context->data[Tree]->tree, context->data[Tree]->tree.current, context->data[Tree]->tree.result);
 }
 
-/* __code get(struct Context* context) { */
-/*     context->data[Tree]->tree.current = context->data[Tree]->tree.root; */
-/*     context->data[Next]->next = context->data[Allocate]->allocate.next; */
-/*     context->data[Allocate]->allocate.next = Traverse; */
+__code get(struct Context* context, struct Tree* tree, struct Node* node) {
+    tree->current = (tree->current == 0)? tree->root : tree->current;
 
-/*     goto meta(context, Compare); */
-/* } */
+    compare(context, tree, tree->current->key, node->key);
+    
+    if (tree->result == 0) {
+        goto meta(context, context->next);
+    } else if (tree->result == 1) {
+        tree->current = tree->current->right;
+    } else {
+        tree->current = tree->current->left;
+    }
+        
+    if (tree->current == 0)
+        goto meta(context, context->next);
+        
+    goto meta(context, Get);
+}
+
+__code get_stub(struct Context* context) {
+    goto get(context, &context->data[Tree]->tree, &context->data[Node]->node);
+}
 
-/* __code traverse(struct Context* context) { */
-/*     int result = context->data[Tree]->tree.result; */
-/*     struct Tree* tree = &context->data[Tree]->tree; */
+__code delete(struct Context* context, struct Tree* tree, struct Allocate* allocate) {
+    allocate->size = sizeof(struct Node);
+    allocator(context);
+
+    tree->current = tree->root;
+    compare(context, tree, tree->current->key, context->data[Node]->node.key);
+    goto meta(context, Replace_d);
+}
+
+__code delete_stub(struct Context* context) {
+    goto delete(context, &context->data[Tree]->tree, &context->data[Allocate]->allocate);
+}
+
+__code replaceNode_d(struct Context* context, struct Tree* tree, struct Node* oldNode, struct Node* newNode, struct Node* node) {
+    *newNode = *oldNode;
+    tree->current = newNode;
     
-/*     if (result == 0) { */
-/*         goto meta(context, context->data[Next]->next); */
-/*     } else if (result == 1) { */
-/*         tree->current = tree->current->right; */
-/*     } else { */
-/*         tree->current = tree->current->left; */
-/*     } */
+    if (tree->result == -1) {
+        
+        if (tree->current->left != 0)
+            if (tree->current->left->left != 0)
+                if (tree->current->left->color != Red && tree->current->left->left->color != Red)
+                    goto meta(context, MoveRedL);
+        
+        stack_push(node_stack, &tree->current);
+
+        tree->current->left = context->heap;
+        tree->current = oldNode->left;
 
-/*     if(tree->current == 0) { */
-/*         goto meta(context, context->data[Next]->next); */
-/*     } */
+        allocator(context);
+        compare(context, tree, tree->current->key, context->data[Node]->node.key);
+        
+        goto meta(context, Replace_d);
+    } else {
+        if (tree->current->left != 0)
+            if (tree->current->left->color = Red) {
+                allocator(context);
+                *context->data[context->dataNum]->node = *tree->current->left;
+                tree->current->left = context->data[context->dataNum]->node;
+                
+                // roatate right
+                struct Node* tmp = tree->current->left;
+                tree->current->left = tmp->right;
+                tmp->right = tree->current;
+                tmp->color = tree->current->color;
+                tree->current->color = Red;
+                tree->current = tmp;
+            }
 
-/*     goto meta(context, Compare); */
-/* } */
+        if (tree->result == 0 && tree->current->right == 0) {
+            stack_pop(node_stack, &tree->current);
+
+            compare(context, tree, tree->current->key, context->data[Node]->node.key);
 
-/* __code delete(struct Context* context) { */
-/*     goto meta(context, Get); */
-/* } */
+            if (tree->result == 1) {
+                tree->current->right = 0;
+            } else {
+                tree->current->left = 0;
+            }
 
-__code code4(struct Context* context) {
-    puts("---before---");
-    print_tree(context->data[Tree]->tree.root, 0);
-    
-    struct Node* node = &context->data[Node]->node;
-    node->key = 0;
-    node->value = 0;
-    
-    context->next = Code5;
+            if (tree->current->right != 0)
+                if (tree->current->right->color == Red)
+                    goto meta(context, RotateL);
+            
+            if (tree->current->left != 0)
+                if (tree->current->left->left != 0)
+                    if (tree->current->left->color == Red && tree->current->left->left->color == Red)
+                        goto meta(context, RotateR);
+            
+            goto meta(context, FixUp);
+        }
+            
 
-    goto meta(context, Put);
+        if (tree->current->right != 0) {
+            if (tree->right->left != 0) {
+                if (tree->current->right->color != Red && tree->current->right->left->color != Red) {
+                    goto meta(context, MoveRedR);
+                }
+            }
+
+            stack_push(node_stack, &tree->current);
+        
+            tree->current->right = context->heap;
+            tree->current = oldNode->right;
+            
+            allocator(context);
+
+            goto(context, Replace_d);
+
+        }
+        
+    allocator(context);
+    compare(context, tree, tree->current->key, context->data[Node]->node.key);
+    goto meta(context, Replace_d);
+}
+
+__code replaceNode_d_stub(struct Context* context) {
+    goto replaceNode_d(context, &context->data[Tree]->tree, context->data[Tree]->tree.current, &context->data[context->dataNum]->node, &context->data[Node]->node);
 }
 
-__code code5(struct Context* context) {
-    puts("---after---");
-    print_tree(context->data[Tree]->tree.root, 0);
-    puts("--Number of Data--");
-    printf("%d\n", context->dataNum);
-    stack_free(pstack);
+__code moveRedLeft(struct Context* context, struct Node* node) {
+    // color flip
+    node->color ^= 1;
+    node->left->color ^= 1;
+    node->right->color ^= 1;
+
+    if (tree->current->right != 0)
+        if (tree->current->right->left != 0)
+            if (tree->current->right->left == Red) {
+                allocator(context);
+                *context->data[context->dataNum]->node = *node->right;
+                node->right = context->data[context->dataNum]->node;
+                
+                allocator(context);
+                *context->data[context->dataNum]->node = *node->right->left;
+                node->right->left = context->data[context->dataNum]->node;
+
+                // rotate right
+                struct Node* tmp = node->right->left;
+                node->right->left = tmp->right;
+                tmp->right = node->right;
+                tmp->color = node->right->color;
+                node->right->color = Red;
+                node->right = tmp;
 
-    goto meta(context, Exit);
+                // rotate left
+                tmp = node->right;
+                node->right = tmp->left;
+                tmp->left = node;
+                tmp->color = node->color;
+                node->color = Red;
+
+                // color flip
+                node->color ^= 1;
+                node->left->color ^= 1;
+                node->right->color ^= 1;
+
+                tree->current = tmp;
+            }
+
+    stack_push(node_stack, &tree->current);
+
+    tree->current->left = context->heap;
+    tree->current = oldNode->left;
+
+    allocator(context);
+    compare(context, tree, tree->current->key, context->data[Node]->node.key);
+    
+    goto meta(context, Replace_d);
 }
 
-/* __code code6(struct Context* context) { */
-/*     puts("---get---"); */
-/*     print_tree(context->data[Tree]->tree.current, 0); */
-/*     goto meta(context, Exit); */
-/* } */
+__code moveRedRight(struct Context* context, struct Node* node) {
+    // color flip
+    node->color ^= 1;
+    node->left->color ^= 1;
+    node->right->color ^= 1;
+
+    if (tree->current->left != 0)
+        if (tree->current->left->left != 0)
+            if (tree->current->left->left == Red) {
+                allocator(context);
+                *context->data[context->dataNum]->node = *node->left;
+                node->left = context->data[context->dataNum]->node;
+                
+                // rotate right
+                struct Node* tmp = node->left;
+                node->left = tmp->right;
+                tmp->right = node;
+                tmp->color = node->color;
+                node->color = Red;
+
+                // color flip
+                node->color ^= 1;
+                node->left->color ^= 1;
+                node->right->color ^= 1;
 
-int main(int argc, char** argv) {
-    num = (int)atoi(argv[1]);
-    pstack = stack_init(sizeof(union Data*), num);
-    struct Context* context = (struct Context*)malloc(sizeof(struct Context));
-    initLLRBContext(context);
-    goto start_code(context, Code1);
+                tree->current = tmp;
+            }
+    
+    stack_push(node_stack, &tree->current);
+    
+    tree->current->right = context->heap;
+    tree->prev = tree->current;
+    tree->current = oldNode->right;
+    
+    allocator(context);
+    if (tree->result = 0) {
+        goto meta(context, DeleteMin);
+    } else {
+        compare(context, tree, tree->current->key, context->data[Node]->node.key);
+        
+        goto meta(context, Replace_d);
+    }
+}
+
+__code colorFlip_stub(struct Context* context) {
+    goto colorFlip(context, context->data[Tree]->tree.current);
 }
+
+__code deleteMin(struct Context* context, struct Tree* tree, struct Node* oldNode, struct Node* newNode) {
+    stack_push(node_stack, &newNode);
+    
+    *newNode = *oldNode;
+    tree->current = newNode;
+
+    if (tree->current->left == 0) {
+        newNode->left = 0;
+
+        if (tree->current->right != 0)
+            if (tree->current->right->color == Red)
+                goto meta(context, RotateL);
+        
+        goto meta(context, FixUp);
+    }
+
+    if (tree->current->left != 0)
+        if (tree->current->left->left != 0)
+            if (tree->current->left->color != Red && tree->current->left->left->color != Red)
+                goto meta(context, MoveRedL);
+
+    tree->current = oldNode->left;
+    newNode->left = context->heap;
+
+    allocator(context);
+    goto meta(context, DeleteMin);
+}
+
+__code max_stub(struct Context* context) {
+    goto max(context, &context->data[Tree]->tree, context->data[Tree]->tree.current, &context->data[context->dataNum]->node);
+}