/*
 *  Copyright (C) 2010-2013 JPEXS
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package com.jpexs.decompiler.flash.graph;

import com.jpexs.decompiler.flash.abc.avm2.treemodel.CommentTreeItem;
import com.jpexs.decompiler.flash.action.Action;
import com.jpexs.decompiler.flash.helpers.Highlighting;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Stack;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author JPEXS
 */
public class Graph {

    public List<GraphPart> heads;
    protected GraphSource code;

    public Graph(GraphSource code, List<Integer> alternateEntries) {
        this.code = code;
        heads = makeGraph(code, new ArrayList<GraphPart>(), alternateEntries);
        for (GraphPart head : heads) {
            fixGraph(head);
            makeMulti(head, new ArrayList<GraphPart>());
        }

    }

    protected static void populateParts(GraphPart part, List<GraphPart> allParts) {
        if (allParts.contains(part)) {
            return;
        }
        allParts.add(part);
        for (GraphPart p : part.nextParts) {
            populateParts(p, allParts);
        }
    }

    private void fixGraph(GraphPart part) {
        while (fixGraphOnce(part, new ArrayList<GraphPart>(), false)) {
        }
    }

    private boolean fixGraphOnce(GraphPart part, List<GraphPart> visited, boolean doChildren) {
        if (visited.contains(part)) {
            return false;
        }
        visited.add(part);
        boolean fixed = false;
        int i = 0;
        GraphPath lastpref = null;
        boolean modify = true;
        int prvni = -1;

        if (!doChildren) {

            List<GraphPart> uniqueRefs = new ArrayList<GraphPart>();
            for (GraphPart r : part.refs) {
                if (!uniqueRefs.contains(r)) {
                    uniqueRefs.add(r);
                }
            }
            loopi:
            for (; i <= part.path.length(); i++) {
                lastpref = null;
                int pos = -1;
                for (GraphPart r : uniqueRefs) {
                    pos++;
                    if (r.path.rootName.equals("e") && !part.path.rootName.equals("e")) {
                        continue;
                    }
                    if (part.leadsTo(code, r, new ArrayList<GraphPart>())) {
                        //modify=false;
                        //continue;
                    }

                    prvni = pos;
                    if (i > r.path.length()) {
                        i--;
                        break loopi;
                    }
                    if (lastpref == null) {
                        lastpref = r.path.parent(i);
                    } else {
                        if (!r.path.startsWith(lastpref)) {
                            i--;
                            break loopi;
                        }
                    }
                }
            }
            if (i > part.path.length()) {
                i = part.path.length();
            }
            if (modify && ((uniqueRefs.size() > 1) && (prvni >= 0))) {
                GraphPath prvniUniq = uniqueRefs.get(prvni).path;
                GraphPath newpath = prvniUniq.parent(i);
                if (!part.path.equals(newpath)) {
                    if (part.path.startsWith(newpath) && ((newpath.length() == prvniUniq.length()) || (prvniUniq.getKey(newpath.length()) == part.path.getKey(newpath.length())))) {
                        GraphPath origPath = part.path;
                        GraphPart p = part;
                        part.path = newpath;
                        while (p.nextParts.size() == 1) {
                            p = p.nextParts.get(0);
                            if (!p.path.equals(origPath)) {
                                break;
                            }

                            p.path = newpath;
                        }
                        fixGraphOnce(part, new ArrayList<GraphPart>(), true);
                        fixed = true;
                    }
                }
            }
        } else {

            if (!fixed) {
                if (part.nextParts.size() == 1) {
                    if (!(part.path.rootName.equals("e") && (!part.nextParts.get(0).path.rootName.equals("e")))) {
                        if (part.nextParts.get(0).path.length() > part.path.length()) {
                            part.nextParts.get(0).path = part.path;
                            fixed = true;
                        }
                    }
                }
                if (part.nextParts.size() > 1) {
                    for (int j = 0; j < part.nextParts.size(); j++) {
                        GraphPart npart = part.nextParts.get(j);

                        if (npart.path.length() > part.path.length() + 1) {
                            npart.path = part.path.sub(j, part.end);
                            fixed = true;
                        }
                    }
                }
            }

        }
        if (part.nextParts.size() == 2) {
            if (part.nextParts.get(1).leadsTo(code, part.nextParts.get(0), visited)) {
                fixGraphOnce(part.nextParts.get(1), visited, doChildren);
                fixGraphOnce(part.nextParts.get(0), visited, doChildren);
            } else {
                fixGraphOnce(part.nextParts.get(0), visited, doChildren);
                fixGraphOnce(part.nextParts.get(1), visited, doChildren);
            }
        } else {
            for (int j = part.nextParts.size() - 1; j >= 0; j--) {
                GraphPart p = part.nextParts.get(j);
                fixGraphOnce(p, visited, doChildren);
            }
        }
        return fixed;
    }

    private void makeMulti(GraphPart part, List<GraphPart> visited) {
        if (visited.contains(part)) {
            return;
        }
        visited.add(part);
        GraphPart p = part;
        List<GraphPart> multiList = new ArrayList<GraphPart>();
        multiList.add(p);
        while ((p.nextParts.size() == 1) && (p.nextParts.get(0).refs.size() == 1)) {
            p = p.nextParts.get(0);
            multiList.add(p);
        }
        if (multiList.size() > 1) {
            GraphPartMulti gpm = new GraphPartMulti(multiList);
            gpm.refs = part.refs;
            GraphPart lastPart = multiList.get(multiList.size() - 1);
            gpm.nextParts = lastPart.nextParts;
            for (GraphPart next : gpm.nextParts) {
                int index = next.refs.indexOf(lastPart);
                if (index == -1) {

                    continue;
                }
                next.refs.remove(lastPart);
                next.refs.add(index, gpm);
            }
            for (GraphPart parent : part.refs) {
                if (parent.start == -1) {
                    continue;
                }
                int index = parent.nextParts.indexOf(part);
                if (index == -1) {
                    continue;
                }
                parent.nextParts.remove(part);
                parent.nextParts.add(index, gpm);
            }
        }
        for (int i = 0; i < part.nextParts.size(); i++) {
            makeMulti(part.nextParts.get(i), visited);
        }
    }

    public GraphPart deepCopy(GraphPart part, List<GraphPart> visited, List<GraphPart> copies) {
        if (visited == null) {
            visited = new ArrayList<GraphPart>();
        }
        if (copies == null) {
            copies = new ArrayList<GraphPart>();
        }
        if (visited.contains(part)) {
            return copies.get(visited.indexOf(part));
        }
        visited.add(part);
        GraphPart copy = new GraphPart(part.start, part.end);
        copy.path = part.path;
        copies.add(copy);
        copy.nextParts = new ArrayList<GraphPart>();
        for (int i = 0; i < part.nextParts.size(); i++) {
            copy.nextParts.add(deepCopy(part.nextParts.get(i), visited, copies));
        }
        for (int i = 0; i < part.refs.size(); i++) {
            copy.refs.add(deepCopy(part.refs.get(i), visited, copies));
        }
        return copy;
    }

    public void resetGraph(GraphPart part, List<GraphPart> visited) {
        if (visited.contains(part)) {
            return;
        }
        visited.add(part);
        int pos = 0;
        for (GraphPart p : part.nextParts) {
            if (!visited.contains(p)) {
                p.path = part.path.sub(pos, p.end);
            }
            resetGraph(p, visited);
            pos++;
        }
    }

    public GraphPart getCommonPart(List<GraphPart> parts) {
        GraphPart head = new GraphPart(0, 0);
        head.nextParts.addAll(parts);
        List<GraphPart> allVisited = new ArrayList<GraphPart>();
        head = deepCopy(head, allVisited, null);
        for (GraphPart g : head.nextParts) {
            for (GraphPart r : g.refs) {
                r.nextParts.remove(g);
            }
            g.refs.clear();
            g.refs.add(head);
        }
        head.path = new GraphPath();
        resetGraph(head, new ArrayList<GraphPart>());
        fixGraph(head);

        /*Graph gr=new Graph();
         gr.heads=new ArrayList<GraphPart>();
         gr.heads.add(head);
         GraphFrame gf=new GraphFrame(gr, "");
         gf.setVisible(true);
         */

        GraphPart next = head.getNextPartPath(new ArrayList<GraphPart>());
        if (next == null) {
            return null;
        }
        for (GraphPart g : allVisited) {
            if (g.start == next.start) {
                return g;
            }
        }
        return null;
    }

    public GraphPart getNextNoJump(GraphPart part) {
        while (code.get(part.start).isJump()) {
            part = part.getSubParts().get(0).nextParts.get(0);
        }
        return part;
    }

    public static List<GraphTargetItem> translateViaGraph(List localData, String path, GraphSource code, List<Integer> alternateEntries) {
        Graph g = new Graph(code, alternateEntries);
        return g.translate(localData);
    }

    public List<GraphTargetItem> translate(List localData) {
        List<GraphPart> allParts = new ArrayList<GraphPart>();
        for (GraphPart head : heads) {
            populateParts(head, allParts);
        }
        Stack<GraphTargetItem> stack = new Stack<GraphTargetItem>();
        List<GraphTargetItem> ret = printGraph(new ArrayList<GraphPart>(), localData, stack, allParts, null, heads.get(0), null, new ArrayList<Loop>(), new HashMap<Loop, List<GraphTargetItem>>());
        processIfs(ret);
        finalProcessStack(stack, ret);
        finalProcessAll(ret, 0);
        return ret;
    }

    public void finalProcessStack(Stack<GraphTargetItem> stack, List<GraphTargetItem> output) {
    }

    private void finalProcessAll(List<GraphTargetItem> list, int level) {
        finalProcess(list, level);
        for (GraphTargetItem item : list) {
            if (item instanceof Block) {
                List<List<GraphTargetItem>> subs = ((Block) item).getSubs();
                for (List<GraphTargetItem> sub : subs) {
                    finalProcessAll(sub, level + 1);
                }
            }
        }
    }

    protected void finalProcess(List<GraphTargetItem> list, int level) {
    }

    private void processIfs(List<GraphTargetItem> list) {
        for (int i = 0; i < list.size(); i++) {
            GraphTargetItem item = list.get(i);
            if (item instanceof Block) {
                List<List<GraphTargetItem>> subs = ((Block) item).getSubs();
                for (List<GraphTargetItem> sub : subs) {
                    processIfs(sub);
                }
            }
            if ((item instanceof LoopItem) && (item instanceof Block)) {
                List<List<GraphTargetItem>> subs = ((Block) item).getSubs();
                for (List<GraphTargetItem> sub : subs) {
                    processIfs(sub);
                    checkContinueAtTheEnd(sub, ((LoopItem) item).loop);
                }
            }
            if (item instanceof IfItem) {
                IfItem ifi = (IfItem) item;
                List<GraphTargetItem> onTrue = ifi.onTrue;
                List<GraphTargetItem> onFalse = ifi.onFalse;
                if ((!onTrue.isEmpty()) && (!onFalse.isEmpty())) {
                    if (onTrue.get(onTrue.size() - 1) instanceof ContinueItem) {
                        if (onFalse.get(onFalse.size() - 1) instanceof ContinueItem) {
                            if (((ContinueItem) onTrue.get(onTrue.size() - 1)).loopId == ((ContinueItem) onFalse.get(onFalse.size() - 1)).loopId) {
                                onTrue.remove(onTrue.size() - 1);
                                list.add(i + 1, onFalse.remove(onFalse.size() - 1));
                            }
                        }
                    }
                }

                if ((!onTrue.isEmpty()) && (!onFalse.isEmpty())) {
                    GraphTargetItem last = onTrue.get(onTrue.size() - 1);
                    if ((last instanceof ExitItem) || (last instanceof ContinueItem) || (last instanceof BreakItem)) {
                        list.addAll(i + 1, onFalse);
                        onFalse.clear();
                    }
                }

                if ((!onTrue.isEmpty()) && (!onFalse.isEmpty())) {
                    if (onFalse.get(onFalse.size() - 1) instanceof ExitItem) {
                        if (onTrue.get(onTrue.size() - 1) instanceof ContinueItem) {
                            list.add(i + 1, onTrue.remove(onTrue.size() - 1));
                        }
                    }
                }
            }
        }

        //Same continues in onTrue and onFalse gets continue on parent level


    }

    protected List<GraphPart> getLoopsContinues(List<Loop> loops) {
        List<GraphPart> ret = new ArrayList<GraphPart>();
        for (Loop l : loops) {
            if (l.loopContinue != null) {
                ret.add(l.loopContinue);
            }
        }
        return ret;
    }

    protected GraphTargetItem checkLoop(GraphPart part, GraphPart stopPart, List<Loop> loops) {
        if (part == stopPart) {
            return null;
        }
        for (Loop l : loops) {
            if (l.loopContinue == part) {
                return (new ContinueItem(null, l.id));
            }
            if (l.loopBreak == part) {
                return (new BreakItem(null, l.id));
            }
        }
        return null;
    }

    private void checkContinueAtTheEnd(List<GraphTargetItem> commands, Loop loop) {
        if (!commands.isEmpty()) {
            if (commands.get(commands.size() - 1) instanceof ContinueItem) {
                if (((ContinueItem) commands.get(commands.size() - 1)).loopId == loop.id) {
                    commands.remove(commands.size() - 1);
                }
            }
        }
    }

    protected boolean isEmpty(List<GraphTargetItem> output) {
        if (output.isEmpty()) {
            return true;
        }
        return false;
    }

    protected List<GraphTargetItem> check(GraphSource code, List localData, List<GraphPart> allParts, Stack<GraphTargetItem> stack, GraphPart parent, GraphPart part, GraphPart stopPart, List<Loop> loops, List<GraphTargetItem> output, HashMap<Loop, List<GraphTargetItem>> forFinalCommands) {
        return null;
    }

    protected GraphPart checkPart(List localData, GraphPart part) {
        return part;
    }

    protected GraphTargetItem translatePartGetStack(List localData, GraphPart part, Stack<GraphTargetItem> stack) {
        stack = (Stack<GraphTargetItem>) stack.clone();
        translatePart(localData, part, stack);
        return stack.pop();
    }

    protected List<GraphTargetItem> translatePart(List localData, GraphPart part, Stack<GraphTargetItem> stack) {
        List<GraphPart> sub = part.getSubParts();
        List<GraphTargetItem> ret = new ArrayList<GraphTargetItem>();
        int end = 0;
        for (GraphPart p : sub) {
            if (p.end == -1) {
                p.end = code.size() - 1;
            }
            if (p.start == code.size()) {
                continue;
            } else if (p.end == code.size()) {
                p.end--;
            }
            end = p.end;
            int start = p.start;
            ret.addAll(code.translatePart(part, localData, stack, start, end));
        }
        return ret;
    }

    protected List<GraphTargetItem> printGraph(List<GraphPart> visited, List localData, Stack<GraphTargetItem> stack, List<GraphPart> allParts, GraphPart parent, GraphPart part, GraphPart stopPart, List<Loop> loops, HashMap<Loop, List<GraphTargetItem>> forFinalCommands) {
        if (visited.contains(part)) {
            //return new ArrayList<GraphTargetItem>();
        } else {
            visited.add(part);
        }
        List<GraphTargetItem> ret = new ArrayList<GraphTargetItem>();
        try {
            boolean debugMode = false;

            if (debugMode) {
                System.err.println("PART " + part);
            }

            while (((part != null) && (part.getHeight() == 1)) && (code.size() > part.start) && (code.get(part.start).isJump())) {  //Parts with only jump in it gets ignored                

                if (part == stopPart) {
                    return ret;
                }
                GraphTargetItem lop = checkLoop(part.nextParts.get(0), stopPart, loops);
                if (lop == null) {
                    part = part.nextParts.get(0);
                } else {
                    break;
                }
            }

            if ((part != null) && (code.size() <= part.start)) {
                ret.add(new ScriptEndItem());
                return ret;
            }

            if (part == stopPart) {
                return ret;
            }
            if (part == null) {
                //return ret;
            }
            part = checkPart(localData, part);
            if (part == null) {
                return ret;
            }

            if (part.ignored) {
                return ret;
            }
            List<String> fqn = new ArrayList<String>();
            //HashMap<Integer, String> lrn = new HashMap<Integer, String>();
            List<GraphTargetItem> output = new ArrayList<GraphTargetItem>();
            //boolean isSwitch = false;

            // code.initToSource();
            List<GraphPart> parts = new ArrayList<GraphPart>();
            if (part instanceof GraphPartMulti) {
                parts = ((GraphPartMulti) part).parts;
            } else {
                parts.add(part);
            }
            boolean isIf = false;
            int end = part.end;
            for (GraphPart p : parts) {
                end = p.end;
                int start = p.start;
                isIf = false;
                /*if (code.get(end).isBranch()) {
                 end--;
                 }*/

                try {
                    output.addAll(code.translatePart(p, localData, stack, start, end));
                    if ((end >= code.size() - 1) && p.nextParts.isEmpty()) {
                        output.add(new ScriptEndItem());
                    }
                } catch (Exception ex) {
                    Logger.getLogger(Graph.class.getName()).log(Level.SEVERE, "error during printgraph", ex);
                    return ret;
                }
            }
            if (part.nextParts.size() == 2) {
                if (!stack.isEmpty()) {
                    GraphTargetItem top = stack.peek();
                    if (false) { //top.isCompileTime()){
                        stack.pop();
                        if (top.toBoolean()) {
                            ret.addAll(output);
                            ret.addAll(printGraph(visited, localData, stack, allParts, parent, part.nextParts.get(0), stopPart, loops, forFinalCommands));
                            return ret;
                        } else {
                            ret.addAll(output);
                            ret.addAll(printGraph(visited, localData, stack, allParts, parent, part.nextParts.get(1), stopPart, loops, forFinalCommands));
                            return ret;
                        }
                    } else {
                    }
                } else {
                    //EMPTY STACK
                }
            }
            if (part.nextParts.size() == 2) {
                if (part.nextParts.get(0) == part.nextParts.get(1)) {
                    if (!stack.isEmpty()) {
                        GraphTargetItem expr = stack.pop();
                        if (expr instanceof LogicalOpItem) {
                            expr = ((LogicalOpItem) expr).invert();
                        } else {
                            expr = new NotItem(null, expr);
                        }
                        output.add(new IfItem(null, expr, new ArrayList<GraphTargetItem>(), new ArrayList<GraphTargetItem>()));
                    }
                    part.nextParts.remove(0);
                }
            }

            if (part.nextParts.size() == 2) {

                if ((stack.size() >= 2) && (stack.get(stack.size() - 1) instanceof NotItem) && (((NotItem) (stack.get(stack.size() - 1))).getOriginal().getNotCoerced() == stack.get(stack.size() - 2).getNotCoerced())) {
                    ret.addAll(output);
                    GraphPart sp0 = getNextNoJump(part.nextParts.get(0));
                    GraphPart sp1 = getNextNoJump(part.nextParts.get(1));
                    boolean reversed = false;
                    List<GraphPart> loopContinues = getLoopsContinues(loops);
                    loopContinues.add(part);
                    if (sp1.leadsTo(code, sp0, loopContinues)) {
                    } else if (sp0.leadsTo(code, sp1, loopContinues)) {
                        reversed = true;
                    }
                    GraphPart next = reversed ? sp0 : sp1;
                    GraphTargetItem ti;
                    if ((ti = checkLoop(next, stopPart, loops)) != null) {
                        ret.add(ti);
                    } else {

                        printGraph(visited, localData, stack, allParts, parent, next, reversed ? sp1 : sp0, loops, forFinalCommands);
                        GraphTargetItem second = stack.pop();
                        GraphTargetItem first = stack.pop();

                        if (!reversed) {
                            AndItem a = new AndItem(null, first, second);
                            stack.push(a);
                            a.firstPart = part;
                            if (second instanceof AndItem) {
                                a.firstPart = ((AndItem) second).firstPart;
                            }
                            if (second instanceof OrItem) {
                                a.firstPart = ((OrItem) second).firstPart;
                            }
                        } else {
                            OrItem o = new OrItem(null, first, second);
                            stack.push(o);
                            o.firstPart = part;
                            if (second instanceof AndItem) {
                                o.firstPart = ((AndItem) second).firstPart;
                            }
                            if (second instanceof OrItem) {
                                o.firstPart = ((OrItem) second).firstPart;
                            }
                        }
                        next = reversed ? sp1 : sp0;
                        if ((ti = checkLoop(next, stopPart, loops)) != null) {
                            ret.add(ti);
                        } else {
                            ret.addAll(printGraph(visited, localData, stack, allParts, parent, next, stopPart, loops, forFinalCommands));
                        }
                    }
                    return ret;
                } else if ((stack.size() >= 2) && (stack.get(stack.size() - 1).getNotCoerced() == stack.get(stack.size() - 2).getNotCoerced())) {
                    ret.addAll(output);
                    GraphPart sp0 = getNextNoJump(part.nextParts.get(0));
                    GraphPart sp1 = getNextNoJump(part.nextParts.get(1));
                    boolean reversed = false;
                    List<GraphPart> loopContinues = getLoopsContinues(loops);
                    loopContinues.add(part);
                    if (sp1.leadsTo(code, sp0, loopContinues)) {
                    } else if (sp0.leadsTo(code, sp1, loopContinues)) {
                        reversed = true;
                    }
                    GraphPart next = reversed ? sp0 : sp1;
                    GraphTargetItem ti;
                    if ((ti = checkLoop(next, stopPart, loops)) != null) {
                        ret.add(ti);
                    } else {
                        printGraph(visited, localData, stack, allParts, parent, next, reversed ? sp1 : sp0, loops, forFinalCommands);
                        GraphTargetItem second = stack.pop();
                        GraphTargetItem first = stack.pop();

                        if (reversed) {
                            AndItem a = new AndItem(null, first, second);
                            stack.push(a);
                            a.firstPart = part;
                            if (second instanceof AndItem) {
                                a.firstPart = ((AndItem) second).firstPart;
                            }
                            if (second instanceof OrItem) {
                                a.firstPart = ((AndItem) second).firstPart;
                            }
                        } else {
                            OrItem o = new OrItem(null, first, second);
                            stack.push(o);
                            o.firstPart = part;
                            if (second instanceof OrItem) {
                                o.firstPart = ((OrItem) second).firstPart;
                            }
                            if (second instanceof OrItem) {
                                o.firstPart = ((OrItem) second).firstPart;
                            }
                        }

                        next = reversed ? sp1 : sp0;
                        if ((ti = checkLoop(next, stopPart, loops)) != null) {
                            ret.add(ti);
                        } else {
                            ret.addAll(printGraph(visited, localData, stack, allParts, parent, next, stopPart, loops, forFinalCommands));
                        }
                    }

                    return ret;
                }
            }



            List<GraphPart> loopContinues = getLoopsContinues(loops);
            boolean loop = false;
            boolean reversed = false;
            boolean whileTrue = false;
            Loop whileTrueLoop = null;
            if ((!part.nextParts.isEmpty()) && part.nextParts.get(0).leadsTo(code, part, loopContinues)) {
                if ((part.nextParts.size() > 1) && part.nextParts.get(1).leadsTo(code, part, loopContinues)) {
                    if (output.isEmpty()) {
                        whileTrueLoop = new Loop(loops.size(), part, null);
                        loops.add(whileTrueLoop);
                        whileTrue = true;
                    } else {
                        loop = true;//doWhile
                    }

                } else {
                    loop = true;
                }
            } else if ((part.nextParts.size() > 1) && part.nextParts.get(1).leadsTo(code, part, loopContinues)) {
                loop = true;
                reversed = true;
            }


            Loop lc = null;
            if (part.leadsTo(code, part, loopContinues)) {
                lc = new Loop(loops.size(), part, null);
                loops.add(lc);
            }

            List<GraphTargetItem> retChecked = null;
            if ((retChecked = check(code, localData, allParts, stack, parent, part, stopPart, loops, output, forFinalCommands)) != null) {
                if (lc != null) {
                    List<GraphTargetItem> trueExp = new ArrayList<GraphTargetItem>();
                    trueExp.add(new TrueItem(null));
                    boolean chwt = true;

                    if (!retChecked.isEmpty()) { //doWhileCheck
                        checkContinueAtTheEnd(retChecked, lc);
                        List<GraphTargetItem> finalCommands = forFinalCommands.get(lc);
                        IfItem ifi = null;
                        if ((finalCommands != null) && !finalCommands.isEmpty()) {
                            if (finalCommands.get(finalCommands.size() - 1) instanceof IfItem) {
                                ifi = (IfItem) finalCommands.get(finalCommands.size() - 1);
                                finalCommands.remove(finalCommands.size() - 1);
                            }
                        } else if (retChecked.get(retChecked.size() - 1) instanceof IfItem) {
                            ifi = (IfItem) retChecked.get(retChecked.size() - 1);
                            retChecked.remove(retChecked.size() - 1);
                        }
                        if (ifi != null) {
                            if (ifi.onFalse.isEmpty()) {
                                if (!ifi.onTrue.isEmpty()) {
                                    if (ifi.onTrue.get(ifi.onTrue.size() - 1) instanceof ExitItem) {
                                        whileTrue = false;
                                        List<GraphTargetItem> tr = new ArrayList<GraphTargetItem>();
                                        GraphTargetItem ex = ifi.expression;
                                        if (ex instanceof LogicalOpItem) {
                                            ex = ((LogicalOpItem) ex).invert();
                                        } else {
                                            ex = new NotItem(null, ex);
                                        }
                                        if ((finalCommands != null) && (!finalCommands.isEmpty())) {
                                            tr.addAll(finalCommands);
                                        }
                                        tr.add(ex);
                                        ret.add(new DoWhileItem(null, lc, retChecked, tr));
                                        ret.addAll(ifi.onTrue);
                                        chwt = false;
                                    }
                                }
                            }
                        }
                    }

                    if (chwt) {
                        ret.add(new WhileItem(null, lc, trueExp, retChecked));
                    }
                } else {
                    ret.addAll(retChecked);
                }
                return ret;
            } else {
                if (lc != null) {
                    loops.remove(lc);
                }
            }

            /* if ( part.leadsTo(code, part, getLoopsContinues(loops))) {
             Loop l = new Loop(loops.size(), part, null);
             List<GraphTargetItem> trueExp = new ArrayList<GraphTargetItem>();
             trueExp.add(new TrueItem(null));
             loops.add(l);
             List<GraphTargetItem> wtbody=new ArrayList<GraphTargetItem>();
             wtbody.addAll(output);
             wtbody.addAll(printGraph(visited, localData, stack, allParts, parent, part, stopPart, loops, forFinalCommands));
             ret.add(new WhileItem(null, l, trueExp, wtbody));
             return ret;
             }*/
            if (((part.nextParts.size() == 2) || ((part.nextParts.size() == 1) && loop)) /*&& (!isSwitch)*/) {

                boolean doWhile = loop;
                if (loop && output.isEmpty()) {
                    doWhile = false;
                }
                Loop currentLoop = null;
                if (loop) {
                    currentLoop = new Loop(loops.size(), part, null);
                    loops.add(currentLoop);
                }



                if ((!whileTrue) && loop && (part.nextParts.size() > 1) && (!doWhile)) {
                    currentLoop.loopBreak = part.nextParts.get(reversed ? 0 : 1);
                }

                forFinalCommands.put(currentLoop, new ArrayList<GraphTargetItem>());

                GraphTargetItem expr = null;
                if (part.nextParts.size() == 1) {
                    expr = new TrueItem(null);
                } else {
                    if (!stack.isEmpty()) {
                        expr = stack.pop();
                    }
                }
                /*if (loop) {
                 GraphTargetItem expr2 = expr;
                 if (expr2 instanceof NotItem) {
                 expr2 = ((NotItem) expr2).getOriginal();
                 }                    
                 }*/

                if (doWhile) {
                    //ret.add(new DoWhileTreeItem(null, currentLoop.id, part.start, output, expr));
                } else {
                    ret.addAll(output);
                }
                if (loop) {
                    GraphPart f = expr.getFirstPart();
                    if (f != null) {
                        currentLoop.loopContinue = f;
                    }
                }
                GraphPart loopBodyStart = null;
                if ((reversed == loop) || doWhile) {
                    if (expr instanceof LogicalOpItem) {
                        expr = ((LogicalOpItem) expr).invert();
                    } else {
                        expr = new NotItem(null, expr);
                    }
                }

                loopContinues = getLoopsContinues(loops);
                GraphPart next = part.getNextPartPath(loopContinues);
                List<GraphTargetItem> retx = ret;
                if ((!loop) || (doWhile && (part.nextParts.size() > 1))) {
                    if (doWhile) {
                        retx = output;

                    }
                    int stackSizeBefore = stack.size();
                    Stack<GraphTargetItem> trueStack = (Stack<GraphTargetItem>) stack.clone();
                    Stack<GraphTargetItem> falseStack = (Stack<GraphTargetItem>) stack.clone();
                    GraphTargetItem lopTrue = checkLoop(part.nextParts.get(1), stopPart, loops);
                    GraphTargetItem lopFalse = null;
                    if (next != part.nextParts.get(0)) {
                        lopFalse = checkLoop(part.nextParts.get(0), stopPart, loops);
                    }
                    List<GraphTargetItem> onTrue = new ArrayList<GraphTargetItem>();
                    if (lopTrue != null) {
                        onTrue.add(lopTrue);
                    } else {
                        if (debugMode) {
                            System.err.println("ONTRUE: (inside " + part + ")");
                        }
                        onTrue = printGraph(visited, prepareBranchLocalData(localData), trueStack, allParts, part, part.nextParts.get(1), next == null ? stopPart : next, loops, forFinalCommands);
                        if (debugMode) {
                            System.err.println("/ONTRUE (inside " + part + ")");
                        }
                    }
                    List<GraphTargetItem> onFalse = new ArrayList<GraphTargetItem>();
                    if ((!onTrue.isEmpty()) && onTrue.get(onTrue.size() - 1) instanceof ExitItem) {
                        next = part.nextParts.get(0);
                    } else {
                        if (lopFalse != null) {
                            onFalse.add(lopFalse);
                        } else {
                            if (debugMode) {
                                System.err.println("ONFALSE: (inside " + part + ")");
                            }
                            if ((next == part.nextParts.get(0)) || (part.nextParts.get(0).path.equals(part.path) || part.nextParts.get(0).path.length() < part.path.length())) {
                                onFalse = new ArrayList<GraphTargetItem>();
                            } else {
                                onFalse = (printGraph(visited, prepareBranchLocalData(localData), falseStack, allParts, part, part.nextParts.get(0), next == null ? stopPart : next, loops, forFinalCommands));
                            }
                            if (debugMode) {
                                System.err.println("/ONFALSE (inside " + part + ")");
                            }
                        }
                    }
                    if (isEmpty(onTrue) && isEmpty(onFalse) && (trueStack.size() > stackSizeBefore) && (falseStack.size() > stackSizeBefore)) {
                        stack.push(new TernarOpItem(null, expr, trueStack.pop(), falseStack.pop()));
                    } else {
                        List<GraphTargetItem> retw = retx;
                        if (whileTrue) {
                            retw = new ArrayList<GraphTargetItem>();
                            retw.add(new IfItem(null, expr, onTrue, onFalse));

                            List<GraphTargetItem> body = new ArrayList<GraphTargetItem>();
                            if (next != null) {
                                body = printGraph(visited, prepareBranchLocalData(localData), stack, allParts, part, next, stopPart, loops, forFinalCommands);
                            }
                            retw.addAll(body);


                            if (!retw.isEmpty()) { //doWhileCheck
                                checkContinueAtTheEnd(retw, whileTrueLoop);
                                List<GraphTargetItem> finalCommands = forFinalCommands.get(whileTrueLoop);
                                IfItem ifi = null;
                                if ((finalCommands != null) && !finalCommands.isEmpty()) {
                                    if (finalCommands.get(finalCommands.size() - 1) instanceof IfItem) {
                                        ifi = (IfItem) finalCommands.get(finalCommands.size() - 1);
                                        finalCommands.remove(finalCommands.size() - 1);
                                    }
                                } else if (retw.get(retw.size() - 1) instanceof IfItem) {
                                    ifi = (IfItem) retw.get(retw.size() - 1);
                                    retw.remove(retw.size() - 1);
                                }
                                if (ifi != null) {
                                    if (ifi.onFalse.isEmpty()) {
                                        if (!ifi.onTrue.isEmpty()) {
                                            if (ifi.onTrue.get(ifi.onTrue.size() - 1) instanceof ExitItem) {
                                                whileTrue = false;
                                                List<GraphTargetItem> tr = new ArrayList<GraphTargetItem>();
                                                GraphTargetItem ex = ifi.expression;
                                                if (ex instanceof LogicalOpItem) {
                                                    ex = ((LogicalOpItem) ex).invert();
                                                } else {
                                                    ex = new NotItem(null, ex);
                                                }
                                                if ((finalCommands != null) && (!finalCommands.isEmpty())) {
                                                    tr.addAll(finalCommands);
                                                }
                                                tr.add(ex);
                                                retx.add(new DoWhileItem(null, whileTrueLoop, retw, tr));
                                                retx.addAll(ifi.onTrue);
                                                next = null;
                                            }
                                        }
                                    }
                                }
                            }
                            if (whileTrue) {
                                List<GraphTargetItem> tr = new ArrayList<GraphTargetItem>();
                                tr.add(new TrueItem(null));
                                retx.add(new WhileItem(null, whileTrueLoop, tr, retw));
                                next = null;
                            }
                        } else {
                            retx.add(new IfItem(null, expr, onTrue, onFalse));
                        }

                    }
                    if (doWhile) {
                        loopBodyStart = next;
                    }
                    if (whileTrue) {
                        loopBodyStart = part;
                    }
                }
                if (loop) { // && (!doWhile)) {
                    List<GraphTargetItem> loopBody = new ArrayList<GraphTargetItem>();
                    List<GraphTargetItem> finalCommands = null;
                    GraphPart finalPart = null;
                    GraphTargetItem ti;
                    if ((loopBodyStart != null) && ((ti = checkLoop(loopBodyStart, stopPart, loops)) != null)) {
                        loopBody.add(ti);
                    } else {
                        if (!(doWhile && (loopBodyStart == null))) {
                            loopBody = printGraph(visited, prepareBranchLocalData(localData), stack, allParts, part, loopBodyStart != null ? loopBodyStart : part.nextParts.get(reversed ? 1 : 0), stopPart, loops, forFinalCommands);
                        }
                    }
                    checkContinueAtTheEnd(loopBody, currentLoop);
                    finalCommands = forFinalCommands.get(currentLoop);
                    if (!finalCommands.isEmpty()) {
                        ret.add(new ForTreeItem(null, currentLoop, new ArrayList<GraphTargetItem>(), expr, finalCommands, loopBody));
                    } else {
                        if (doWhile) {
                            if (stack.isEmpty() || (part.nextParts.size() == 1)) {
                                expr = new TrueItem(null);
                            } else {
                                expr = stack.pop();
                            }
                            loopBody.addAll(0, output);
                            if (part.nextParts.size() == 1) {
                                loopBody.addAll(printGraph(visited, prepareBranchLocalData(localData), stack, allParts, part, part.nextParts.get(0), stopPart, loops, forFinalCommands));
                            }

                            checkContinueAtTheEnd(loopBody, currentLoop);

                            List<GraphTargetItem> newBody = new ArrayList<GraphTargetItem>();
                            List<GraphTargetItem> nextcmds = new ArrayList<GraphTargetItem>();
                            if ((!loopBody.isEmpty()) && (loopBody.get(loopBody.size() - 1) instanceof IfItem)) {
                                IfItem ift = (IfItem) loopBody.get(loopBody.size() - 1);
                                if ((!ift.onFalse.isEmpty()) && (ift.onFalse.get(ift.onFalse.size() - 1) instanceof ExitItem)) {//((ift.onFalse.size() == 1) && (ift.onFalse.get(0) instanceof ContinueItem) && (((ContinueItem) ift.onFalse.get(0)).loopId == currentLoop.id))) {
                                    if (ift.expression != null) {
                                        expr = ift.expression;
                                        /*if (expr instanceof LogicalOpItem) {
                                         expr = ((LogicalOpItem) expr).invert();
                                         } else {
                                         expr = new NotItem(null, expr);
                                         }*/
                                    }
                                    nextcmds = ift.onFalse;
                                    newBody = ift.onTrue;

                                    loopBody.remove(loopBody.size() - 1);
                                } else if ((!ift.onTrue.isEmpty()) && (ift.onTrue.get(ift.onTrue.size() - 1) instanceof ExitItem)) {//((ift.onTrue.size() == 1) && (ift.onTrue.get(0) instanceof ContinueItem) && (((ContinueItem) ift.onTrue.get(0)).loopId == currentLoop.id))) {
                                    if (ift.expression != null) {
                                        expr = ift.expression;
                                        if (expr instanceof LogicalOpItem) {
                                            expr = ((LogicalOpItem) expr).invert();
                                        } else {
                                            expr = new NotItem(null, expr);
                                        }
                                    }
                                    newBody = ift.onFalse;
                                    nextcmds = ift.onTrue;
                                    loopBody.remove(loopBody.size() - 1);
                                    if (newBody.isEmpty()) {
                                        //addIf.addAll(loopBody);
                                    }
                                }
                            }
                            checkContinueAtTheEnd(newBody, currentLoop);
                            if ((!newBody.isEmpty()) && (!(newBody.get(0) instanceof ScriptEndItem))) { // && (addIf.get(addIf.size() - 1) instanceof ContinueItem) && (((ContinueItem) addIf.get(addIf.size() - 1)).loopId == currentLoop.id)) {
                                loopBody.add(expr);
                                ret.add(new WhileItem(null, currentLoop, loopBody, newBody));
                                ret.addAll(nextcmds);
                            } else {
                                List<GraphTargetItem> ex = new ArrayList<GraphTargetItem>();
                                ex.add(expr);
                                ret.add(new DoWhileItem(null, currentLoop, loopBody, ex));
                                ret.addAll(nextcmds);
                            }

                        } else {
                            List<GraphTargetItem> ex = new ArrayList<GraphTargetItem>();
                            ex.add(expr);
                            ret.add(new WhileItem(null, currentLoop, ex, loopBody));
                        }
                    }
                }
                if ((!doWhile) && (!whileTrue) && loop && (part.nextParts.size() > 1)) {
                    loops.remove(currentLoop); //remove loop so no break shows up
                    //ret.addAll(printGraph(methodPath, stack, scopeStack, allParts, parsedExceptions, finallyJumps, level, part, part.nextParts.get(reversed ? 0 : 1), stopPart, loops, localRegs, body, ignoredSwitches));
                    next = part.nextParts.get(reversed ? 0 : 1);
                }
                if (doWhile) {
                    next = null;
                }
                if (next != null) {
                    GraphTargetItem ti = checkLoop(next, stopPart, loops);
                    if (ti != null) {
                        ret.add(ti);
                    } else {
                        if (debugMode) {
                            System.err.println("NEXT: (inside " + part + ")");
                        }
                        ret.addAll(printGraph(visited, localData, stack, allParts, part, next, stopPart, loops, forFinalCommands));
                        if (debugMode) {
                            System.err.println("/NEXT: (inside " + part + ")");
                        }
                    }

                }
            } else {
                ret.addAll(output);
            }
            onepart:
            if (part.nextParts.size() == 1 && (!loop)) {
                /*if (part.end - part.start > 4) {
                 if (code.code.get(part.end).definition instanceof PopIns) {
                 if (code.code.get(part.end - 1).definition instanceof LabelIns) {
                 if (code.code.get(part.end - 2).definition instanceof PushByteIns) {

                 //if (code.code.get(part.end - 3).definition instanceof SetLocalTypeIns) {
                 if (part.nextParts.size() == 1) {
                 GraphPart sec = part.nextParts.get(0);

                 if (code.code.get(sec.end).definition instanceof ReturnValueIns) {
                 if (sec.end - sec.start >= 3) {
                 if (code.code.get(sec.end - 1).definition instanceof KillIns) {
                 if (code.code.get(sec.end - 2).definition instanceof GetLocalTypeIns) {
                 if (!output.isEmpty()) {
                 if (output.get(output.size() - 1) instanceof SetLocalTreeItem) {
                 sec.ignored = true;
                 ret.add(new ReturnValueTreeItem(code.code.get(sec.end), ((SetLocalTreeItem) output.get(output.size() - 1)).value));
                 break onepart;
                 }
                 }
                 }
                 }
                 }

                 } else if (code.code.get(sec.end).definition instanceof ReturnVoidIns) {
                 ret.add(new ReturnVoidTreeItem(code.code.get(sec.end)));
                 break onepart;
                 }
                 //}
                 }
                 }
                 }
                 }
                 }

                 for (int f : finallyJumps) {
                 if (part.nextParts.get(0).start == f) {
                 if ((!output.isEmpty()) && (output.get(output.size() - 1) instanceof SetLocalTreeItem)) {
                 ret.add(new ReturnValueTreeItem(null, ((SetLocalTreeItem) output.get(output.size() - 1)).value));
                 } else {
                 ret.add(new ReturnVoidTreeItem(null));
                 }

                 break onepart;
                 }
                 }
                 */
                GraphPart p = part.nextParts.get(0);
                GraphTargetItem lop = checkLoop(p, stopPart, loops);
                if (lop == null) {
                    if (p.path.length() >= part.path.length()) {
                        ret.addAll(printGraph(visited, localData, stack, allParts, part, p, stopPart, loops, forFinalCommands));
                    } else {
                        if ((p != stopPart) && (p.refs.size() > 1)) {
                            List<GraphPart> nextList = new ArrayList<GraphPart>();
                            populateParts(p, nextList);
                            Loop nearestLoop = null;
                            loopn:
                            for (GraphPart n : nextList) {
                                for (Loop l : loops) {
                                    if (l.loopContinue == n) {
                                        nearestLoop = l;
                                        break loopn;
                                    }
                                }
                            }
                            if ((nearestLoop != null)) {// && (nearestLoop.loopBreak != null)) {
                                List<GraphTargetItem> finalCommands = printGraph(visited, localData, stack, allParts, part, p, nearestLoop.loopContinue, loops, forFinalCommands);
                                nearestLoop.loopContinue = p;
                                forFinalCommands.put(nearestLoop, finalCommands);
                                ContinueItem cti = new ContinueItem(null, nearestLoop.id);
                                ret.add(cti);
                            }
                        }
                    }
                } else {
                    ret.add(lop);
                }
                //}
                //ret += (strOfChars(level, TAB) + "continue;\r\n");
                //}
            }
            /*if (isSwitch && (!ignoredSwitches.contains(part.end))) {
             //ret.add(new CommentTreeItem(code.code.get(part.end), "Switch not supported"));
             TreeItem switchedObject = stack.pop();
             List<TreeItem> caseValues = new ArrayList<TreeItem>();
             List<Integer> valueMappings = new ArrayList<Integer>();
             List<List<TreeItem>> caseCommands = new ArrayList<List<TreeItem>>();

             GraphPart next = part.getNextPartPath(loopContinues);
             int breakPos = -1;
             if (next != null) {
             breakPos = next.start;
             }
             List<TreeItem> defaultCommands = printGraph(methodPath, stack, scopeStack, allParts, parsedExceptions, finallyJumps, level + 1, part, part.nextParts.get(0), stopPart, loops, localRegs, body, ignoredSwitches);

             for (int i = 0; i < part.nextParts.size() - 1; i++) {
             caseValues.add(new IntegerValueTreeItem(null, (Long) (long) i));
             valueMappings.add(i);
             GraphPart nextCase = next;
             List<TreeItem> caseBody = new ArrayList<TreeItem>();
             if (i < part.nextParts.size() - 1 - 1) {
             if (!part.nextParts.get(1 + i).leadsTo(part.nextParts.get(1 + i + 1), new ArrayList<GraphPart>())) {
             caseBody.add(new BreakTreeItem(null, breakPos));
             } else {
             nextCase = part.nextParts.get(1 + i + 1);
             }
             } else if (!part.nextParts.get(1 + i).leadsTo(part.nextParts.get(0), new ArrayList<GraphPart>())) {
             caseBody.add(new BreakTreeItem(null, breakPos));
             } else {
             nextCase = part.nextParts.get(0);
             }
             caseBody.addAll(0, printGraph(methodPath, stack, scopeStack, allParts, parsedExceptions, finallyJumps, level + 1, part, part.nextParts.get(1 + i), nextCase, loops, localRegs, body, ignoredSwitches));
             caseCommands.add(caseBody);
             }

             SwitchTreeItem swt = new SwitchTreeItem(null, breakPos, switchedObject, caseValues, caseCommands, defaultCommands, valueMappings);
             ret.add(swt);

             if (next != null) {
             TreeItem lopNext = checkLoop(next, stopPart, loops);
             if (lopNext != null) {
             ret.add(lopNext);
             } else {
             ret.addAll(printGraph(methodPath, stack, scopeStack, allParts, parsedExceptions, finallyJumps, level + 1, part, next, stopPart, loops, localRegs, body, ignoredSwitches));
             }
             }

             }*/

            /*code.clearTemporaryRegisters(ret);
             if (!part.forContinues.isEmpty()) {
             throw new ForException(new ArrayList<TreeItem>(), ret, part);
             }*/
            return ret;
        } catch (StackOverflowError soe) {
            ret.add(new CommentTreeItem(null, "StackOverflowError"));
            Logger.getLogger(Graph.class.getName()).log(Level.SEVERE, "error during printGraph", soe);
            return ret;
        }
    }

    private List<GraphPart> makeGraph(GraphSource code, List<GraphPart> allBlocks, List<Integer> alternateEntries) {
        HashMap<Integer, List<Integer>> refs = code.visitCode(alternateEntries);
        List<GraphPart> ret = new ArrayList<GraphPart>();
        boolean visited[] = new boolean[code.size()];
        ret.add(makeGraph(null, new GraphPath(), code, 0, 0, allBlocks, refs, visited));
        for (int pos : alternateEntries) {
            GraphPart e1 = new GraphPart(-1, -1);
            e1.path = new GraphPath("e");
            ret.add(makeGraph(e1, new GraphPath("e"), code, pos, pos, allBlocks, refs, visited));
        }
        return ret;
    }

    protected int checkIp(int ip) {
        return ip;
    }

    private GraphPart makeGraph(GraphPart parent, GraphPath path, GraphSource code, int startip, int lastIp, List<GraphPart> allBlocks, HashMap<Integer, List<Integer>> refs, boolean visited2[]) {

        int ip = startip;
        for (GraphPart p : allBlocks) {
            if (p.start == ip) {
                p.refs.add(parent);
                return p;
            }
        }
        GraphPart g;
        GraphPart ret = new GraphPart(ip, -1);
        ret.path = path;
        GraphPart part = ret;
        while (ip < code.size()) {
            if (visited2[ip] || ((ip != startip) && (refs.get(ip).size() > 1))) {
                part.end = lastIp;
                GraphPart found = null;
                for (GraphPart p : allBlocks) {
                    if (p.start == ip) {
                        found = p;
                        break;
                    }
                }

                allBlocks.add(part);

                if (found != null) {
                    part.nextParts.add(found);
                    found.refs.add(part);
                    break;
                } else {
                    GraphPart gp = new GraphPart(ip, -1);
                    gp.path = path;
                    part.nextParts.add(gp);
                    gp.refs.add(part);
                    part = gp;
                }
            }

            ip = checkIp(ip);
            lastIp = ip;
            GraphSourceItem ins = code.get(ip);
            if (ins.isIgnored()) {
                ip++;
                continue;
            }
            if (ins instanceof GraphSourceItemContainer) {
                GraphSourceItemContainer cnt = (GraphSourceItemContainer) ins;
                if (ins instanceof Action) { //TODO: Remove dependency of AVM1
                    long endAddr = ((Action) ins).getAddress() + cnt.getHeaderSize();
                    for (long size : cnt.getContainerSizes()) {
                        endAddr += size;
                    }
                    ip = code.adr2pos(endAddr);
                }
                continue;
            } else if (ins.isExit()) {
                part.end = ip;
                allBlocks.add(part);
                break;
            } else if (ins.isJump()) {
                part.end = ip;
                allBlocks.add(part);
                ip = ins.getBranches(code).get(0);
                part.nextParts.add(g = makeGraph(part, path, code, ip, lastIp, allBlocks, refs, visited2));
                g.refs.add(part);
                break;
            } else if (ins.isBranch()) {
                part.end = ip;

                allBlocks.add(part);
                List<Integer> branches = ins.getBranches(code);
                for (int i = 0; i < branches.size(); i++) {
                    part.nextParts.add(g = makeGraph(part, path.sub(i, ip), code, branches.get(i), ip, allBlocks, refs, visited2));
                    g.refs.add(part);
                }
                break;
            }
            ip++;
        }
        if ((part.end == -1) && (ip >= code.size())) {
            if (part.start == code.size()) {
                part.end = code.size();
                allBlocks.add(part);
            } else {
                part.end = ip - 1;
                for (GraphPart p : allBlocks) {
                    if (p.start == ip) {
                        p.refs.add(part);
                        part.nextParts.add(p);
                        allBlocks.add(part);
                        return ret;
                    }
                }
                GraphPart gp = new GraphPart(ip, ip);
                allBlocks.add(gp);
                gp.refs.add(part);
                part.nextParts.add(gp);
                allBlocks.add(part);
            }
        }
        return ret;
    }
    /**
     * String used to indent line when converting to string
     */
    public static final String INDENTOPEN = "INDENTOPEN";
    /**
     * String used to unindent line when converting to string
     */
    public static final String INDENTCLOSE = "INDENTCLOSE";
    private static final String INDENT_STRING = "   ";

    private static String tabString(int len) {
        String ret = "";
        for (int i = 0; i < len; i++) {
            ret += INDENT_STRING;
        }
        return ret;
    }

    /**
     * Converts list of TreeItems to string
     *
     * @param tree List of TreeItem
     * @return String
     */
    public static String graphToString(List<GraphTargetItem> tree, Object... localData) {
        StringBuilder ret = new StringBuilder();
        List localDataList = new ArrayList();
        for (Object o : localData) {
            localDataList.add(o);
        }
        for (GraphTargetItem ti : tree) {
            if (!ti.isEmpty()) {
                ret.append(ti.toStringSemicoloned(localDataList));
                ret.append("\r\n");
            }
        }
        String parts[] = ret.toString().split("\r\n");
        ret = new StringBuilder();


        try {
            Stack<String> loopStack = new Stack<String>();
            for (int p = 0; p < parts.length; p++) {
                String stripped = Highlighting.stripHilights(parts[p]);
                if (stripped.endsWith(":") && (!stripped.startsWith("case ")) && (!stripped.equals("default:"))) {
                    loopStack.add(stripped.substring(0, stripped.length() - 1));
                }
                if (stripped.startsWith("break ")) {
                    if (stripped.equals("break " + loopStack.peek().replace("switch", "") + ";")) {
                        parts[p] = parts[p].replace(" " + loopStack.peek().replace("switch", ""), "");
                    }
                }
                if (stripped.startsWith("continue ")) {
                    if (loopStack.size() > 0) {
                        int pos = loopStack.size() - 1;
                        String loopname = "";
                        do {
                            loopname = loopStack.get(pos);
                            pos--;
                        } while ((pos >= 0) && (loopname.startsWith("loopswitch")));
                        if (stripped.equals("continue " + loopname + ";")) {
                            parts[p] = parts[p].replace(" " + loopname, "");
                        }
                    }
                }
                if (stripped.startsWith(":")) {
                    loopStack.pop();
                }
            }
        } catch (Exception ex) {
        }

        int level = 0;
        for (int p = 0; p < parts.length; p++) {
            String strippedP = Highlighting.stripHilights(parts[p]).trim();
            if (strippedP.endsWith(":") && (!strippedP.startsWith("case ")) && (!strippedP.equals("default:"))) {
                String loopname = strippedP.substring(0, strippedP.length() - 1);
                boolean dorefer = false;
                for (int q = p + 1; q < parts.length; q++) {
                    String strippedQ = Highlighting.stripHilights(parts[q]).trim();
                    if (strippedQ.equals("break " + loopname + ";")) {
                        dorefer = true;
                        break;
                    }
                    if (strippedQ.equals("continue " + loopname + ";")) {
                        dorefer = true;
                        break;
                    }
                    if (strippedQ.equals(":" + loopname)) {
                        break;
                    }
                }
                if (!dorefer) {
                    continue;
                }
            }
            if (strippedP.startsWith(":")) {
                continue;
            }
            if (Highlighting.stripHilights(parts[p]).equals(INDENTOPEN)) {
                level++;
                continue;
            }
            if (Highlighting.stripHilights(parts[p]).equals(INDENTCLOSE)) {
                level--;
                continue;
            }
            if (Highlighting.stripHilights(parts[p]).equals("}")) {
                level--;
            }
            if (Highlighting.stripHilights(parts[p]).equals("};")) {
                level--;
            }
            ret.append(tabString(level));
            ret.append(parts[p]);
            ret.append("\r\n");
            if (Highlighting.stripHilights(parts[p]).equals("{")) {
                level++;
            }
        }
        return ret.toString();
    }

    public List prepareBranchLocalData(List localData) {
        return localData;
    }
}