Page 1 of 2 12 LastLast
Results 1 to 10 of 13

Thread: QuickSort

  1. #1
    Developer Sor's Avatar
    Join Date
    Aug 2010
    Location
    The Medieval City of Bruges
    Posts
    747

    Post QuickSort

    We are currently covering arrays and sorting techniques at my college. Well, the basic algorithms, anyway. Of course, this is old news to me,
    but it seems my fellow students don't realize the importance of arrays/lists nor appreciate the logic behind sorting algorithms...

    That last one could just be me, though. But I was upset at the fact that we weren't going to write more advanced sorting algorithms or even our own.
    I know for a fact that I'm the only one upset about this. No one else cares, they'd rather just whip up some good old
    Code:
    arr.Sort()
    and get it over with.

    So for the occasion, I decided to refresh my memory regarding the 'QuickSort' algorithm. The following script is the implementation for the MoHAA running the Reborn patch.
    This algorithm will quickly sort (in-place) any one-dimensional, 0-/1-indexed array of numbers or strings in ascending or descending order. Strings are sorted according
    to their ASCII bytes but cases are ignored.
    The other script file is for all other Medal of Honor games and it only supports number arrays, since it would require a more elaborate character-to-integer conversion.

    Script
    Code:
    // ARGS: <0/1-indexed 1D array>     <0=numbers; 1=strings>         <0=ascending; 1=descending>
    qsort group.array local.type local.desc:
        // parse array
        if ((typeof group.array) != "array" && (typeof group.array) != "const array") {
            end 0;
        }
        
        // Type to compare:
        if (local.type) {
            group.compare = "compare_str";
        } else {
            group.compare = "compare_num";
        }
        
        // 'descending' or 'ascending' switches:
        if (local.desc) {
            group.smallerThan = 1;
            group.greaterThan = -1;
        } else {
            group.smallerThan = -1;
            group.greaterThan = 1;
        }
    
    
        // quickly sort array
        if (group.array[0] != NIL) {
            waitthread _qsort 0 (group.array.size - 1);
        } else {
            waitthread _qsort 1 group.array.size;
        } 
    
    
        // finish up
        thread _destructor;
    end group.array;
    
    
    _qsort local.left local.right:
        local.l = local.left;
        local.r = local.right;
        local.pivot = group.array[(local.left + local.right) / 2];
        
        while !(local.r < local.l) {
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) {
                local.l++;
                continue;
            }
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) {
                local.r--;
                continue;
            }
            
            local.tmp = group.array[local.l];
            group.array[local.l] = group.array[local.r];
            group.array[local.r] = local.tmp;
            local.l++;
            local.r--;
        }
        
        // still got some sorting to do..
        if (local.l < local.right) {
            waitthread _qsort local.l local.right;
        } if (local.left < local.r) {
            waitthread _qsort local.left local.r;
        }
    end;
    
    // Technically not necessary as long as logic stays in an isolated script file. 
    // Otherwise, this will automatically clean out the group variables.
    _destructor:
        group.compare = NIL;
        group.smallerThan = NIL;
        group.greaterThan = NIL;
        waitframe;
        group.array = NIL;
    end;
    
    
    compare_num local.el local.p:
        if (local.el < local.p) {
            end -1;
        } else if (local.p < local.el) {
            end 1;
        }
    end 0;
    
    
    compare_str local.el local.p:
        local.el = string(local.el);
        local.p = string(local.p);
    
    
        local.elSize = local.el.size;
        local.pSize = local.p.size;
    
    
        // Only check up to the smallest size
        if (local.elSize < local.pSize) {
            local.smallestSize = local.elSize;
        } else {
            local.smallestSize = local.pSize;
        }
        
        for (local.i = 0; local.i < local.smallestSize; local.i++) {
            local.elChar = charToInt(local.el[local.i]);
            local.pChar = charToInt(local.p[local.i]);
                
            // Handle letter casing..
            if (97 <= local.elChar && local.elChar < 123) {
                local.elChar -= 32;
            } if (97 <= local.pChar && local.pChar < 123) {
                local.pChar -= 32;
            }
    
    
            if (local.elChar < local.pChar) {
                end -1;
            } else if (local.elChar > local.pChar) {
                end 1;
            }
        }
        
        // Equal? Not so sure...
        if (local.elSize < local.pSize) {
            end -1;
        } else if (local.elSize > local.pSize) {
            end 1;
        }
    end 0;
    
    
    // ARGS: <array> <0=vertical or 1=horizontal printing>
    printer local.array local.hori:
        if (local.array[0] != NIL) {
            local.start = 0;
            local.end = local.array.size;
        } else {
            local.start = 1;
            local.end = local.array.size + 1;
        }
        
        if (local.hori) {
            local.suffix = " ";
        } else {
            local.suffix = "\n";
        }
    
    
        for (local.i = local.start; local.i < local.end; local.i++) {
            print (local.array[local.i] + local.suffix);
        }
    end;
    Usage

    For reborn:
    Code:
    //IN
    local.arr[0] = "lime"
    local.arr[1] = "Banana"
    local.arr[2] = "Apricot"
    local.arr[3] = "pineapple"
    local.arr[4] = "grapes"
    local.arr[5] = "apple"
    local.arr[6] = "Orange"
    //last two params are optional, since it is checked for true, not zero
    waitthread aPath/qsort.scr::qsort (( -2)::7::8::0::2::( -4)::6) 0 1
    waitthread aPath/qsort.scr::qsort local.arr 1 0
    will produce
    Code:
     //OUT
    local.array[1] = 8
    local.array[2] = 7
    local.array[3] = 6
    local.array[4] = 2
    local.array[5] = 0
    local.array[6] = -2
    local.array[7] = -4
    
    // AND 
    
    local.arr[0] = apple
    local.arr[1] = Apricot
    local.arr[2] = Banana
    local.arr[3] = grapes
    local.arr[4] = lime
    local.arr[5] = Orange
    local.arr[6] = pineapple
    For the universal script:
    Code:
    waitthread aPath/qsort2.scr::qsort (( -2)::7::8::0::2::( -4)::6) 0 0 //last params are optional, since it is checked for true, not zero
    will produce
    Code:
     //OUT
    local.array[1] = -4
    local.array[2] = -2
    local.array[3] = 0
    local.array[4] = 2
    local.array[5] = 6
    local.array[6] = 7
    local.array[7] = 8
    Download

    qsort.rar
    Last edited by Sor; February 27th, 2013 at 12:41 AM.
    Morpheus Script (MoH) => You try to shoot yourself in the foot only to discover that MorpheusScript already shot your foot for you.

  2. #2
    Über Prodigy & Developer Razo[R]apiD's Avatar
    Join Date
    May 2010
    Location
    Poland, Lublin
    Posts
    3,257

    Default

    Well, the truth is, that QuickSort and HeapSort are the most common algorithms and you rarely need anything else Sometimes even simple insertion sort will do.

    From what I can see, you used recursive approach. Wouldn't it be better to use iterational one? Did you try sorting huge arrays? Morpheus VM has limited stack, so you can overflow it.

    You could also let user pass the compare function. This way QuickSort wouldn't need to know about data type and users could also sort vectors, Entities etc. I don't remember whether it's possible to waitthread "variable", but it could solve type checking for universal script.

    Also.. in QuickSort the pivot is the most important part You could still get a nobel prize for a good pivot alg. Of course the one used is the most common one.
    Additionally, it turns out that simple insertion sort outperforms quick sort when dealing with small arrays.

  3. #3
    Developer Sor's Avatar
    Join Date
    Aug 2010
    Location
    The Medieval City of Bruges
    Posts
    747

    Default

    When I said 'basic' I meant selection, insertion and bubble sort. We're skipping the others for some reason.

    QuickSort does worse than some other algorithms when the array is already sorted or, like you said, when it contains few elements. But would the iterating QSort save more memory?
    Currently, the array is only copied once (by thread call). This sadly isn't a copy of a reference or pointer, though, which is why I initialized the incoming array as a group. variable and treated it accordingly.

    The stack size of constant arrays (made using '::'-operators or the 'makeArray' command) is 1024. As it happens, this includes all 'elements', including the characters of strings,
    the separate values of vectors... Didn't even realize that until I tried to assemble an array of words out of a wikpedia paragraph just now .

    The total stack size for the MorpheusScript is quite high. No one has ever crashed the game by having too many variables (not to my knowledge at least) but I think jv's skylimit mod holds the record for most used.
    The things is non-constant arrays don't seem to have a cap. I just created an array of 2048 elements each containing a 12-character or 24-byte string. Despite the fact that each element
    contains exactly the same string, I tried it and nothing in particular happened (apart from a half-second pause between the println before and after the function call).

    EDIT: the QuickSort with 'compareThread support' has already been implemented in the framework libraries (in absence of a compareThread, the sorting thread is auto-detected) It also supports any integrally indexed-array.
    Last edited by Sor; February 27th, 2013 at 07:33 AM.
    Morpheus Script (MoH) => You try to shoot yourself in the foot only to discover that MorpheusScript already shot your foot for you.

  4. #4
    Administrator James's Avatar
    Join Date
    May 2010
    Location
    on the intraweb
    Posts
    3,180

    Default

    I always thought recursion helped reduce resources and the execution time of an application because it's 1 less jump you need to take to an external function?? I guess it just depends on how many loops and other execution threads you're going through. Obviously MOh scripting and C\C++ programming is different because you can free resources and other things within the application so it doesn't hog too much from the application. I was going to add that I also used bubble sort, insertion and the others you both mention when I took my algorithm class. It would be interesting to to create a sample script that actually feeds the same values into each sort and output the time it takes to finish all iterations. That way you can see which one is effective for which value\s.

    It's great seeing the amount of motivation and passion you have for this Sor. You clearly are a born programmer just like RR. Keep it up man! Damn, now I have to step up my game haha.

  5. #5
    Über Prodigy & Developer Razo[R]apiD's Avatar
    Join Date
    May 2010
    Location
    Poland, Lublin
    Posts
    3,257

    Default

    I think you misunderstood me Sor. Memory allocated for variables is only limited to your RAM. However, there is a memory stack where VM stores arguments.

    In pseudo-code it looks like this:

    STORE VAR1
    STORE VAR2
    CALL FUNCTION

    The stack memory layout is:

    ----------------------------------
    RET ADDR FROM FUNCTION
    ----------------------------------
    VAR2
    ----------------------------------
    VAR1
    ----------------------------------
    ......
    ----------------------------------

    When you use recursion, you push arguments on stack till the last elementary problem and then you rewind by returning from bottom to top.
    If the array is huge (a lot of elements), there is a possibility that recursive QSort will execute itself many times, storing stack frames.

    Stack in VM's is usually an array of some length. I think it's 65k for MoH:AA VM. You can exceed the stack this way.

    Iteration approach makes a single call to the function which is safer. You could try to test my theory, I for sure know that it's possible to exceed the VM's stack, but I don't know how fast.

    EDIT:

    It seems like there is a frame stack counter and you can only have 10 frames (from 0 to 9). You can check this by running with g_scripttrace 1. It will print current frame to the console.

  6. #6
    Developer Sor's Avatar
    Join Date
    Aug 2010
    Location
    The Medieval City of Bruges
    Posts
    747

    Default

    But the array isn't passed around, the two variables for the binary sorting on the other hand are passed on with each recursive call or doesn't this matter?

    So does this frame stack counter mean that only 10 sequences can be done "simultaneously" per frame?

    EDIT: Ah, the stack may overflow with some of the array functions I wrote for the framework, since most functions support multiple dimensions and
    the only way to dynamically access them is by recursion. However, the way it's done ensures that the array is never copied entirely at any given time
    and the recursion will finally contract and this will automatically destroy all temporary copies one by one.

    So it is possible an absurdly large array could ruin the whole things but, really, an array of 1024 or more elements is rarely used in practice.
    Last edited by Sor; February 27th, 2013 at 10:02 AM.
    Morpheus Script (MoH) => You try to shoot yourself in the foot only to discover that MorpheusScript already shot your foot for you.

  7. #7
    Über Prodigy & Developer Razo[R]apiD's Avatar
    Join Date
    May 2010
    Location
    Poland, Lublin
    Posts
    3,257

    Default

    Arguments of _qsort are put on stack. As far as I understand the stack pointer in the VM, it will show "stack overflow" exception when this counter is increased above 9.

    This means that something like this could possibly cause an overflow:


    Code:
    QuickSort
             |
             --> _qsort
             |          |
             |          --> _qsort
             |                     |
             --> _qsort         --> _qsort
                        |
                        --> _qsort
                                   |
                                   --> _qsort

    so on, till the execution flow reaches 10th level deep. This could be tested by running qsort with sorted array of 11+ elements, or any simple recursion function like:

    Code:
    Test local.depth:
         conprintf local.depth
         waitthread Test local.depth+1
    end

  8. #8
    Developer Sor's Avatar
    Join Date
    Aug 2010
    Location
    The Medieval City of Bruges
    Posts
    747

    Default

    Here are the g_scripttrace logs for the function:
    Code:
        waitthread reborn/tmp/qsort.scr::qsort local.ca 0 0 (reborn/reborn_loader.scr, 75, 06A56A4C, 0)
    +++THREAD: 06A56CF4 06A4C62C
    +++FRAME: 1 (06A56CF4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    qsort group.array local.type local.desc: (reborn/tmp/qsort.scr, 5, 06A56CF4, 0)
        if ((typeof group.array) != "array" && (typeof group.array) != "const array") { (reborn/tmp/qsort.scr, 7, 06A56CF4, 0)
        if (local.type) { (reborn/tmp/qsort.scr, 12, 06A56CF4, 0)
            group.compare = "compare_num"; (reborn/tmp/qsort.scr, 15, 06A56CF4, 0)
        if (local.desc) { (reborn/tmp/qsort.scr, 19, 06A56CF4, 0)
            group.smallerThan = -1; (reborn/tmp/qsort.scr, 23, 06A56CF4, 0)
            group.greaterThan = 1; (reborn/tmp/qsort.scr, 24, 06A56CF4, 0)
        if (group.array[0] != NIL) { (reborn/tmp/qsort.scr, 28, 06A56CF4, 0)
        if (group.array[0] != NIL) { (reborn/tmp/qsort.scr, 28)
        if (group.array^
    
    
    ^~^~^ Script Error: array index 0 out of range
    
    
            waitthread _qsort 1 group.array.size; (reborn/tmp/qsort.scr, 31, 06A56CF4, 0)
    +++THREAD: 06A56D1C 06A4C62C
    +++FRAME: 2 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    _qsort local.left local.right: (reborn/tmp/qsort.scr, 38, 06A56D1C, 0)
        local.l = local.left; (reborn/tmp/qsort.scr, 39, 06A56D1C, 0)
        local.r = local.right; (reborn/tmp/qsort.scr, 40, 06A56D1C, 0)
        local.pivot = group.array[(local.left + local.right) / 2]; (reborn/tmp/qsort.scr, 41, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56D44 06A4C62C
    +++FRAME: 3 (06A56D44) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56D44, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56D44, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A56D44, 1)
    ---THREAD: 06A56D44
    ---FRAME: 3 (06A56D44) -------------------------------------------------------------------
    ---FRAME: 2 (06A56D1C) -------------------------------------------------------------------
    ---FRAME: 1 (06A56CF4) -------------------------------------------------------------------
    ---FRAME: 0 (06A56A4C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56D6C 06A4C62C
    +++FRAME: 1 (06A56D6C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56D6C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56D6C, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A56D6C, 1)
    ---THREAD: 06A56D6C
    ---FRAME: 1 (06A56D6C) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56D94 06A4C62C
    +++FRAME: 1 (06A56D94) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56D94, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56D94, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A56D94, 1)
    ---THREAD: 06A56D94
    ---FRAME: 1 (06A56D94) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56DBC 06A4C62C
    +++FRAME: 1 (06A56DBC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56DBC, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56DBC, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A56DBC, 1)
    ---THREAD: 06A56DBC
    ---FRAME: 1 (06A56DBC) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56DE4 06A4C62C
    +++FRAME: 1 (06A56DE4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56DE4, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56DE4, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A56DE4, 1)
    ---THREAD: 06A56DE4
    ---FRAME: 1 (06A56DE4) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56E0C 06A4C62C
    +++FRAME: 1 (06A56E0C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56E0C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56E0C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56E0C, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A56E0C, 1)
    ---THREAD: 06A56E0C
    ---FRAME: 1 (06A56E0C) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 0)
    +++THREAD: 06A56E34 06A4C62C
    +++FRAME: 1 (06A56E34) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56E34, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56E34, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56E34, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A56E34, 1)
    ---THREAD: 06A56E34
    ---FRAME: 1 (06A56E34) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56E5C 06A4C62C
    +++FRAME: 1 (06A56E5C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56E5C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56E5C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56E5C, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A56E5C, 1)
    ---THREAD: 06A56E5C
    ---FRAME: 1 (06A56E5C) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 0)
    +++THREAD: 06A56E84 06A4C62C
    +++FRAME: 1 (06A56E84) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56E84, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56E84, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56E84, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A56E84, 1)
    ---THREAD: 06A56E84
    ---FRAME: 1 (06A56E84) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56EAC 06A4C62C
    +++FRAME: 1 (06A56EAC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56EAC, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56EAC, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56EAC, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A56EAC, 1)
    ---THREAD: 06A56EAC
    ---FRAME: 1 (06A56EAC) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 0)
    +++THREAD: 06A56ED4 06A4C62C
    +++FRAME: 1 (06A56ED4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56ED4, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56ED4, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56ED4, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A56ED4, 1)
    ---THREAD: 06A56ED4
    ---FRAME: 1 (06A56ED4) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56EFC 06A4C62C
    +++FRAME: 1 (06A56EFC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56EFC, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56EFC, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56EFC, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A56EFC, 1)
    ---THREAD: 06A56EFC
    ---FRAME: 1 (06A56EFC) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 0)
    +++THREAD: 06A56F24 06A4C62C
    +++FRAME: 1 (06A56F24) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56F24, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56F24, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56F24, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A56F24, 1)
    ---THREAD: 06A56F24
    ---FRAME: 1 (06A56F24) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56F4C 06A4C62C
    +++FRAME: 1 (06A56F4C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56F4C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56F4C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56F4C, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A56F4C, 1)
    ---THREAD: 06A56F4C
    ---FRAME: 1 (06A56F4C) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 0)
    +++THREAD: 06A56F74 06A4C62C
    +++FRAME: 1 (06A56F74) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56F74, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56F74, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56F74, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A56F74, 1)
    ---THREAD: 06A56F74
    ---FRAME: 1 (06A56F74) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56F9C 06A4C62C
    +++FRAME: 1 (06A56F9C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56F9C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56F9C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56F9C, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A56F9C, 1)
    ---THREAD: 06A56F9C
    ---FRAME: 1 (06A56F9C) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 0)
    +++THREAD: 06A56FC4 06A4C62C
    +++FRAME: 1 (06A56FC4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56FC4, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56FC4, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56FC4, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A56FC4, 1)
    ---THREAD: 06A56FC4
    ---FRAME: 1 (06A56FC4) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A56D1C, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 0)
    +++THREAD: 06A56FEC 06A4C62C
    +++FRAME: 1 (06A56FEC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A56FEC, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A56FEC, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A56FEC, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A56FEC, 1)
    ---THREAD: 06A56FEC
    ---FRAME: 1 (06A56FEC) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A56D1C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 0)
    +++THREAD: 06A57014 06A4C62C
    +++FRAME: 1 (06A57014) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57014, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57014, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57014, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57014, 1)
    ---THREAD: 06A57014
    ---FRAME: 1 (06A57014) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A56D1C, 1)
            local.tmp = group.array[local.l]; (reborn/tmp/qsort.scr, 53, 06A56D1C, 0)
            group.array[local.l] = group.array[local.r]; (reborn/tmp/qsort.scr, 54, 06A56D1C, 0)
            group.array[local.r] = local.tmp; (reborn/tmp/qsort.scr, 55, 06A56D1C, 0)
            local.l++; (reborn/tmp/qsort.scr, 56, 06A56D1C, 0)
            local.r--; (reborn/tmp/qsort.scr, 57, 06A56D1C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A56D1C, 0)
        if (local.l < local.right) { (reborn/tmp/qsort.scr, 61, 06A56D1C, 0)
            waitthread _qsort local.l local.right; (reborn/tmp/qsort.scr, 62, 06A56D1C, 0)
    +++THREAD: 06A5703C 06A4C62C
    +++FRAME: 1 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    _qsort local.left local.right: (reborn/tmp/qsort.scr, 38, 06A5703C, 0)
        local.l = local.left; (reborn/tmp/qsort.scr, 39, 06A5703C, 0)
        local.r = local.right; (reborn/tmp/qsort.scr, 40, 06A5703C, 0)
        local.pivot = group.array[(local.left + local.right) / 2]; (reborn/tmp/qsort.scr, 41, 06A5703C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A5703C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 0)
    +++THREAD: 06A57064 06A4C62C
    +++FRAME: 2 (06A57064) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57064, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57064, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A57064, 1)
    ---THREAD: 06A57064
    ---FRAME: 2 (06A57064) -------------------------------------------------------------------
    ---FRAME: 1 (06A5703C) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A5703C, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A5703C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A5703C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 0)
    +++THREAD: 06A5708C 06A4C62C
    +++FRAME: 1 (06A5708C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5708C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5708C, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A5708C, 1)
    ---THREAD: 06A5708C
    ---FRAME: 1 (06A5708C) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A5703C, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A5703C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A5703C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 0)
    +++THREAD: 06A570B4 06A4C62C
    +++FRAME: 1 (06A570B4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A570B4, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A570B4, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A570B4, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A570B4, 1)
    ---THREAD: 06A570B4
    ---FRAME: 1 (06A570B4) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A5703C, 0)
    +++THREAD: 06A570DC 06A4C62C
    +++FRAME: 1 (06A570DC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A570DC, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A570DC, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A570DC, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A570DC, 1)
    ---THREAD: 06A570DC
    ---FRAME: 1 (06A570DC) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A5703C, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A5703C, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A5703C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A5703C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 0)
    +++THREAD: 06A57104 06A4C62C
    +++FRAME: 1 (06A57104) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57104, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57104, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57104, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57104, 1)
    ---THREAD: 06A57104
    ---FRAME: 1 (06A57104) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A5703C, 0)
    +++THREAD: 06A5712C 06A4C62C
    +++FRAME: 1 (06A5712C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5712C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5712C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5712C, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A5712C, 1)
    ---THREAD: 06A5712C
    ---FRAME: 1 (06A5712C) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A5703C, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A5703C, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A5703C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A5703C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 0)
    +++THREAD: 06A57154 06A4C62C
    +++FRAME: 1 (06A57154) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57154, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57154, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57154, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57154, 1)
    ---THREAD: 06A57154
    ---FRAME: 1 (06A57154) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A5703C, 0)
    +++THREAD: 06A5717C 06A4C62C
    +++FRAME: 1 (06A5717C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5717C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5717C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5717C, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A5717C, 1)
    ---THREAD: 06A5717C
    ---FRAME: 1 (06A5717C) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A5703C, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A5703C, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A5703C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A5703C, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 0)
    +++THREAD: 06A571A4 06A4C62C
    +++FRAME: 1 (06A571A4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A571A4, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A571A4, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A571A4, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A571A4, 1)
    ---THREAD: 06A571A4
    ---FRAME: 1 (06A571A4) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A5703C, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A5703C, 0)
    +++THREAD: 06A571CC 06A4C62C
    +++FRAME: 1 (06A571CC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A571CC, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A571CC, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A571CC, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A571CC, 1)
    ---THREAD: 06A571CC
    ---FRAME: 1 (06A571CC) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A5703C, 1)
            local.tmp = group.array[local.l]; (reborn/tmp/qsort.scr, 53, 06A5703C, 0)
            group.array[local.l] = group.array[local.r]; (reborn/tmp/qsort.scr, 54, 06A5703C, 0)
            group.array[local.r] = local.tmp; (reborn/tmp/qsort.scr, 55, 06A5703C, 0)
            local.l++; (reborn/tmp/qsort.scr, 56, 06A5703C, 0)
            local.r--; (reborn/tmp/qsort.scr, 57, 06A5703C, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A5703C, 0)
        if (local.l < local.right) { (reborn/tmp/qsort.scr, 61, 06A5703C, 0)
            waitthread _qsort local.l local.right; (reborn/tmp/qsort.scr, 62, 06A5703C, 0)
    +++THREAD: 06A571F4 06A4C62C
    +++FRAME: 1 (06A571F4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    _qsort local.left local.right: (reborn/tmp/qsort.scr, 38, 06A571F4, 0)
        local.l = local.left; (reborn/tmp/qsort.scr, 39, 06A571F4, 0)
        local.r = local.right; (reborn/tmp/qsort.scr, 40, 06A571F4, 0)
        local.pivot = group.array[(local.left + local.right) / 2]; (reborn/tmp/qsort.scr, 41, 06A571F4, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A571F4, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A571F4, 0)
    +++THREAD: 06A5721C 06A4C62C
    +++FRAME: 2 (06A5721C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5721C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5721C, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A5721C, 1)
    ---THREAD: 06A5721C
    ---FRAME: 2 (06A5721C) -------------------------------------------------------------------
    ---FRAME: 1 (06A571F4) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A571F4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A571F4, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A571F4, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A571F4, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A571F4, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A571F4, 0)
    +++THREAD: 06A57244 06A4C62C
    +++FRAME: 1 (06A57244) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57244, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57244, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57244, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57244, 1)
    ---THREAD: 06A57244
    ---FRAME: 1 (06A57244) -------------------------------------------------------------------
    ---FRAME: 0 (06A571F4) -------------------------------------------------------------------
    +++FRAME: 0 (06A571F4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A571F4, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A571F4, 0)
    +++THREAD: 06A5726C 06A4C62C
    +++FRAME: 1 (06A5726C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5726C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5726C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5726C, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A5726C, 1)
    ---THREAD: 06A5726C
    ---FRAME: 1 (06A5726C) -------------------------------------------------------------------
    ---FRAME: 0 (06A571F4) -------------------------------------------------------------------
    +++FRAME: 0 (06A571F4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A571F4, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A571F4, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A571F4, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A571F4, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A571F4, 0)
    +++THREAD: 06A57294 06A4C62C
    +++FRAME: 1 (06A57294) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57294, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57294, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57294, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57294, 1)
    ---THREAD: 06A57294
    ---FRAME: 1 (06A57294) -------------------------------------------------------------------
    ---FRAME: 0 (06A571F4) -------------------------------------------------------------------
    +++FRAME: 0 (06A571F4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A571F4, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A571F4, 0)
    +++THREAD: 06A572BC 06A4C62C
    +++FRAME: 1 (06A572BC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A572BC, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A572BC, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A572BC, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A572BC, 1)
    ---THREAD: 06A572BC
    ---FRAME: 1 (06A572BC) -------------------------------------------------------------------
    ---FRAME: 0 (06A571F4) -------------------------------------------------------------------
    +++FRAME: 0 (06A571F4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A571F4, 1)
            local.tmp = group.array[local.l]; (reborn/tmp/qsort.scr, 53, 06A571F4, 0)
            group.array[local.l] = group.array[local.r]; (reborn/tmp/qsort.scr, 54, 06A571F4, 0)
            group.array[local.r] = local.tmp; (reborn/tmp/qsort.scr, 55, 06A571F4, 0)
            local.l++; (reborn/tmp/qsort.scr, 56, 06A571F4, 0)
            local.r--; (reborn/tmp/qsort.scr, 57, 06A571F4, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A571F4, 0)
        if (local.l < local.right) { (reborn/tmp/qsort.scr, 61, 06A571F4, 0)
        } if (local.left < local.r) { (reborn/tmp/qsort.scr, 63, 06A571F4, 0)
    end; (reborn/tmp/qsort.scr, 66, 06A571F4, 0)
    ---THREAD: 06A571F4
    ---FRAME: 0 (06A571F4) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        } if (local.left < local.r) { (reborn/tmp/qsort.scr, 63, 06A5703C, 0)
            waitthread _qsort local.left local.r; (reborn/tmp/qsort.scr, 64, 06A5703C, 0)
    +++THREAD: 06A572E4 06A4C62C
    +++FRAME: 1 (06A572E4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    _qsort local.left local.right: (reborn/tmp/qsort.scr, 38, 06A572E4, 0)
        local.l = local.left; (reborn/tmp/qsort.scr, 39, 06A572E4, 0)
        local.r = local.right; (reborn/tmp/qsort.scr, 40, 06A572E4, 0)
        local.pivot = group.array[(local.left + local.right) / 2]; (reborn/tmp/qsort.scr, 41, 06A572E4, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A572E4, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A572E4, 0)
    +++THREAD: 06A5730C 06A4C62C
    +++FRAME: 2 (06A5730C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5730C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5730C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5730C, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A5730C, 1)
    ---THREAD: 06A5730C
    ---FRAME: 2 (06A5730C) -------------------------------------------------------------------
    ---FRAME: 1 (06A572E4) -------------------------------------------------------------------
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A572E4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A572E4, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A572E4, 0)
    +++THREAD: 06A57334 06A4C62C
    +++FRAME: 1 (06A57334) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57334, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57334, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57334, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A57334, 1)
    ---THREAD: 06A57334
    ---FRAME: 1 (06A57334) -------------------------------------------------------------------
    ---FRAME: 0 (06A572E4) -------------------------------------------------------------------
    +++FRAME: 0 (06A572E4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A572E4, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A572E4, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A572E4, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A572E4, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A572E4, 0)
    +++THREAD: 06A5735C 06A4C62C
    +++FRAME: 1 (06A5735C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5735C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5735C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5735C, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A5735C, 1)
    ---THREAD: 06A5735C
    ---FRAME: 1 (06A5735C) -------------------------------------------------------------------
    ---FRAME: 0 (06A572E4) -------------------------------------------------------------------
    +++FRAME: 0 (06A572E4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A572E4, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A572E4, 0)
    +++THREAD: 06A57384 06A4C62C
    +++FRAME: 1 (06A57384) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57384, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57384, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57384, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57384, 1)
    ---THREAD: 06A57384
    ---FRAME: 1 (06A57384) -------------------------------------------------------------------
    ---FRAME: 0 (06A572E4) -------------------------------------------------------------------
    +++FRAME: 0 (06A572E4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A572E4, 1)
            local.tmp = group.array[local.l]; (reborn/tmp/qsort.scr, 53, 06A572E4, 0)
            group.array[local.l] = group.array[local.r]; (reborn/tmp/qsort.scr, 54, 06A572E4, 0)
            group.array[local.r] = local.tmp; (reborn/tmp/qsort.scr, 55, 06A572E4, 0)
            local.l++; (reborn/tmp/qsort.scr, 56, 06A572E4, 0)
            local.r--; (reborn/tmp/qsort.scr, 57, 06A572E4, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A572E4, 0)
        if (local.l < local.right) { (reborn/tmp/qsort.scr, 61, 06A572E4, 0)
        } if (local.left < local.r) { (reborn/tmp/qsort.scr, 63, 06A572E4, 0)
    end; (reborn/tmp/qsort.scr, 66, 06A572E4, 0)
    ---THREAD: 06A572E4
    ---FRAME: 0 (06A572E4) -------------------------------------------------------------------
    +++FRAME: 0 (06A5703C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    end; (reborn/tmp/qsort.scr, 66, 06A5703C, 0)
    ---THREAD: 06A5703C
    ---FRAME: 0 (06A5703C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        } if (local.left < local.r) { (reborn/tmp/qsort.scr, 63, 06A56D1C, 0)
            waitthread _qsort local.left local.r; (reborn/tmp/qsort.scr, 64, 06A56D1C, 0)
    +++THREAD: 06A573AC 06A4C62C
    +++FRAME: 1 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    _qsort local.left local.right: (reborn/tmp/qsort.scr, 38, 06A573AC, 0)
        local.l = local.left; (reborn/tmp/qsort.scr, 39, 06A573AC, 0)
        local.r = local.right; (reborn/tmp/qsort.scr, 40, 06A573AC, 0)
        local.pivot = group.array[(local.left + local.right) / 2]; (reborn/tmp/qsort.scr, 41, 06A573AC, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A573AC, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 0)
    +++THREAD: 06A573D4 06A4C62C
    +++FRAME: 2 (06A573D4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A573D4, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A573D4, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A573D4, 1)
    ---THREAD: 06A573D4
    ---FRAME: 2 (06A573D4) -------------------------------------------------------------------
    ---FRAME: 1 (06A573AC) -------------------------------------------------------------------
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A573AC, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A573AC, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A573AC, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 0)
    +++THREAD: 06A573FC 06A4C62C
    +++FRAME: 1 (06A573FC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A573FC, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A573FC, 1)
            end -1; (reborn/tmp/qsort.scr, 78, 06A573FC, 1)
    ---THREAD: 06A573FC
    ---FRAME: 1 (06A573FC) -------------------------------------------------------------------
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 1)
                local.l++; (reborn/tmp/qsort.scr, 45, 06A573AC, 0)
                continue; (reborn/tmp/qsort.scr, 46, 06A573AC, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A573AC, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 0)
    +++THREAD: 06A57424 06A4C62C
    +++FRAME: 1 (06A57424) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57424, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57424, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57424, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57424, 1)
    ---THREAD: 06A57424
    ---FRAME: 1 (06A57424) -------------------------------------------------------------------
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A573AC, 0)
    +++THREAD: 06A5744C 06A4C62C
    +++FRAME: 1 (06A5744C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5744C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5744C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5744C, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A5744C, 1)
    ---THREAD: 06A5744C
    ---FRAME: 1 (06A5744C) -------------------------------------------------------------------
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A573AC, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A573AC, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A573AC, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A573AC, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 0)
    +++THREAD: 06A57474 06A4C62C
    +++FRAME: 1 (06A57474) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57474, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57474, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57474, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57474, 1)
    ---THREAD: 06A57474
    ---FRAME: 1 (06A57474) -------------------------------------------------------------------
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A573AC, 0)
    +++THREAD: 06A5749C 06A4C62C
    +++FRAME: 1 (06A5749C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5749C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5749C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5749C, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A5749C, 1)
    ---THREAD: 06A5749C
    ---FRAME: 1 (06A5749C) -------------------------------------------------------------------
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A573AC, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A573AC, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A573AC, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A573AC, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 0)
    +++THREAD: 06A574C4 06A4C62C
    +++FRAME: 1 (06A574C4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A574C4, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A574C4, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A574C4, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A574C4, 1)
    ---THREAD: 06A574C4
    ---FRAME: 1 (06A574C4) -------------------------------------------------------------------
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A573AC, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A573AC, 0)
    +++THREAD: 06A574EC 06A4C62C
    +++FRAME: 1 (06A574EC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A574EC, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A574EC, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A574EC, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A574EC, 1)
    ---THREAD: 06A574EC
    ---FRAME: 1 (06A574EC) -------------------------------------------------------------------
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A573AC, 1)
            local.tmp = group.array[local.l]; (reborn/tmp/qsort.scr, 53, 06A573AC, 0)
            group.array[local.l] = group.array[local.r]; (reborn/tmp/qsort.scr, 54, 06A573AC, 0)
            group.array[local.r] = local.tmp; (reborn/tmp/qsort.scr, 55, 06A573AC, 0)
            local.l++; (reborn/tmp/qsort.scr, 56, 06A573AC, 0)
            local.r--; (reborn/tmp/qsort.scr, 57, 06A573AC, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A573AC, 0)
        if (local.l < local.right) { (reborn/tmp/qsort.scr, 61, 06A573AC, 0)
            waitthread _qsort local.l local.right; (reborn/tmp/qsort.scr, 62, 06A573AC, 0)
    +++THREAD: 06A57514 06A4C62C
    +++FRAME: 1 (06A57514) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    _qsort local.left local.right: (reborn/tmp/qsort.scr, 38, 06A57514, 0)
        local.l = local.left; (reborn/tmp/qsort.scr, 39, 06A57514, 0)
        local.r = local.right; (reborn/tmp/qsort.scr, 40, 06A57514, 0)
        local.pivot = group.array[(local.left + local.right) / 2]; (reborn/tmp/qsort.scr, 41, 06A57514, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A57514, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A57514, 0)
    +++THREAD: 06A5753C 06A4C62C
    +++FRAME: 2 (06A5753C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5753C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5753C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5753C, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A5753C, 1)
    ---THREAD: 06A5753C
    ---FRAME: 2 (06A5753C) -------------------------------------------------------------------
    ---FRAME: 1 (06A57514) -------------------------------------------------------------------
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A57514) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A57514, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A57514, 0)
    +++THREAD: 06A57564 06A4C62C
    +++FRAME: 1 (06A57564) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57564, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57564, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57564, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A57564, 1)
    ---THREAD: 06A57564
    ---FRAME: 1 (06A57564) -------------------------------------------------------------------
    ---FRAME: 0 (06A57514) -------------------------------------------------------------------
    +++FRAME: 0 (06A57514) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A57514, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A57514, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A57514, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A57514, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A57514, 0)
    +++THREAD: 06A5758C 06A4C62C
    +++FRAME: 1 (06A5758C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5758C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5758C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5758C, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A5758C, 1)
    ---THREAD: 06A5758C
    ---FRAME: 1 (06A5758C) -------------------------------------------------------------------
    ---FRAME: 0 (06A57514) -------------------------------------------------------------------
    +++FRAME: 0 (06A57514) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A57514, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A57514, 0)
    +++THREAD: 06A575B4 06A4C62C
    +++FRAME: 1 (06A575B4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A575B4, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A575B4, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A575B4, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A575B4, 1)
    ---THREAD: 06A575B4
    ---FRAME: 1 (06A575B4) -------------------------------------------------------------------
    ---FRAME: 0 (06A57514) -------------------------------------------------------------------
    +++FRAME: 0 (06A57514) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A57514, 1)
            local.tmp = group.array[local.l]; (reborn/tmp/qsort.scr, 53, 06A57514, 0)
            group.array[local.l] = group.array[local.r]; (reborn/tmp/qsort.scr, 54, 06A57514, 0)
            group.array[local.r] = local.tmp; (reborn/tmp/qsort.scr, 55, 06A57514, 0)
            local.l++; (reborn/tmp/qsort.scr, 56, 06A57514, 0)
            local.r--; (reborn/tmp/qsort.scr, 57, 06A57514, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A57514, 0)
        if (local.l < local.right) { (reborn/tmp/qsort.scr, 61, 06A57514, 0)
        } if (local.left < local.r) { (reborn/tmp/qsort.scr, 63, 06A57514, 0)
    end; (reborn/tmp/qsort.scr, 66, 06A57514, 0)
    ---THREAD: 06A57514
    ---FRAME: 0 (06A57514) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        } if (local.left < local.r) { (reborn/tmp/qsort.scr, 63, 06A573AC, 0)
            waitthread _qsort local.left local.r; (reborn/tmp/qsort.scr, 64, 06A573AC, 0)
    +++THREAD: 06A575DC 06A4C62C
    +++FRAME: 1 (06A575DC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    _qsort local.left local.right: (reborn/tmp/qsort.scr, 38, 06A575DC, 0)
        local.l = local.left; (reborn/tmp/qsort.scr, 39, 06A575DC, 0)
        local.r = local.right; (reborn/tmp/qsort.scr, 40, 06A575DC, 0)
        local.pivot = group.array[(local.left + local.right) / 2]; (reborn/tmp/qsort.scr, 41, 06A575DC, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A575DC, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A575DC, 0)
    +++THREAD: 06A57604 06A4C62C
    +++FRAME: 2 (06A57604) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57604, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57604, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57604, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57604, 1)
    ---THREAD: 06A57604
    ---FRAME: 2 (06A57604) -------------------------------------------------------------------
    ---FRAME: 1 (06A575DC) -------------------------------------------------------------------
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A575DC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A575DC, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A575DC, 0)
    +++THREAD: 06A5762C 06A4C62C
    +++FRAME: 1 (06A5762C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5762C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5762C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5762C, 1)
            end 1; (reborn/tmp/qsort.scr, 80, 06A5762C, 1)
    ---THREAD: 06A5762C
    ---FRAME: 1 (06A5762C) -------------------------------------------------------------------
    ---FRAME: 0 (06A575DC) -------------------------------------------------------------------
    +++FRAME: 0 (06A575DC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A575DC, 1)
                local.r--; (reborn/tmp/qsort.scr, 49, 06A575DC, 0)
                continue; (reborn/tmp/qsort.scr, 50, 06A575DC, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A575DC, 0)
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A575DC, 0)
    +++THREAD: 06A57654 06A4C62C
    +++FRAME: 1 (06A57654) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A57654, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A57654, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A57654, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A57654, 1)
    ---THREAD: 06A57654
    ---FRAME: 1 (06A57654) -------------------------------------------------------------------
    ---FRAME: 0 (06A575DC) -------------------------------------------------------------------
    +++FRAME: 0 (06A575DC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.l] local.pivot) == group.smallerThan) { (reborn/tmp/qsort.scr, 44, 06A575DC, 1)
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A575DC, 0)
    +++THREAD: 06A5767C 06A4C62C
    +++FRAME: 1 (06A5767C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    compare_num local.el local.p: (reborn/tmp/qsort.scr, 76, 06A5767C, 1)
        if (local.el < local.p) { (reborn/tmp/qsort.scr, 77, 06A5767C, 1)
        } else if (local.p < local.el) { (reborn/tmp/qsort.scr, 79, 06A5767C, 1)
    end 0; (reborn/tmp/qsort.scr, 82, 06A5767C, 1)
    ---THREAD: 06A5767C
    ---FRAME: 1 (06A5767C) -------------------------------------------------------------------
    ---FRAME: 0 (06A575DC) -------------------------------------------------------------------
    +++FRAME: 0 (06A575DC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
            if ((waitthread group.compare group.array[local.r] local.pivot) == group.greaterThan) { (reborn/tmp/qsort.scr, 48, 06A575DC, 1)
            local.tmp = group.array[local.l]; (reborn/tmp/qsort.scr, 53, 06A575DC, 0)
            group.array[local.l] = group.array[local.r]; (reborn/tmp/qsort.scr, 54, 06A575DC, 0)
            group.array[local.r] = local.tmp; (reborn/tmp/qsort.scr, 55, 06A575DC, 0)
            local.l++; (reborn/tmp/qsort.scr, 56, 06A575DC, 0)
            local.r--; (reborn/tmp/qsort.scr, 57, 06A575DC, 0)
        while !(local.r < local.l) { (reborn/tmp/qsort.scr, 43, 06A575DC, 0)
        if (local.l < local.right) { (reborn/tmp/qsort.scr, 61, 06A575DC, 0)
        } if (local.left < local.r) { (reborn/tmp/qsort.scr, 63, 06A575DC, 0)
    end; (reborn/tmp/qsort.scr, 66, 06A575DC, 0)
    ---THREAD: 06A575DC
    ---FRAME: 0 (06A575DC) -------------------------------------------------------------------
    +++FRAME: 0 (06A573AC) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    end; (reborn/tmp/qsort.scr, 66, 06A573AC, 0)
    ---THREAD: 06A573AC
    ---FRAME: 0 (06A573AC) -------------------------------------------------------------------
    +++FRAME: 0 (06A56D1C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    end; (reborn/tmp/qsort.scr, 66, 06A56D1C, 0)
    ---THREAD: 06A56D1C
    ---FRAME: 0 (06A56D1C) -------------------------------------------------------------------
    +++FRAME: 0 (06A56CF4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        thread _destructor; (reborn/tmp/qsort.scr, 35, 06A56CF4, 0)
    +++THREAD: 06A576A4 06A4C62C
    +++FRAME: 1 (06A576A4) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        group.compare = NIL; (reborn/tmp/qsort.scr, 69, 06A576A4, 0)
        group.smallerThan = NIL; (reborn/tmp/qsort.scr, 70, 06A576A4, 0)
        group.greaterThan = NIL; (reborn/tmp/qsort.scr, 71, 06A576A4, 0)
        waitframe; (reborn/tmp/qsort.scr, 72, 06A576A4, 0)
    ---FRAME: 1 (06A576A4) -------------------------------------------------------------------
    end group.array; (reborn/tmp/qsort.scr, 36, 06A56CF4, 0)
    ---THREAD: 06A56CF4
    ---FRAME: 0 (06A56CF4) -------------------------------------------------------------------
    +++FRAME: 0 (06A56A4C) +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        setcvar g_scripttrace 0 (reborn/reborn_loader.scr, 76, 06A56A4C, 0)
    The stack gets increased to 3 once at the start and does not exceed it for the duration of the algorithm. I think this also has something to do with the fact that I use
    'waitthread' as opposed to 'thread' during the recursion.

    EDIT: confirmed, the 'waitthread' prevents the potential overflow I guess my philosophy to use 'thread' and 'exec' only if I require something to be run simultaneously is paying off.

    However, the other recursion script did in fact crash my server with a stack overflow error at depth 9 just as you predicted.
    Last edited by Sor; February 27th, 2013 at 12:31 PM.
    Morpheus Script (MoH) => You try to shoot yourself in the foot only to discover that MorpheusScript already shot your foot for you.

  9. #9
    Über Prodigy & Developer Razo[R]apiD's Avatar
    Join Date
    May 2010
    Location
    Poland, Lublin
    Posts
    3,257

    Default

    If it crashed then qsort will also crash. qsort if O(n log n) right? Or O(logn) ? You can count how many array elements will cause it to crash.

  10. #10
    Developer Sor's Avatar
    Join Date
    Aug 2010
    Location
    The Medieval City of Bruges
    Posts
    747

    Default

    I tried qsort on a completely sorted array of 2048 elements. Nothing happened. Like I said, 'waitthread' prevents the recursion from expanding too rapidly.
    Morpheus Script (MoH) => You try to shoot yourself in the foot only to discover that MorpheusScript already shot your foot for you.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •