--- /dev/null	2016-05-10 17:52:27.219330981 +0300
+++ new/test/testlibrary/jittester/src/jdk/test/lib/jittester/visitors/ByteCodeVisitor.java	2016-05-12 04:25:00.886334320 +0300
@@ -0,0 +1,1831 @@
+/*
+ * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jdk.test.lib.jittester.visitors;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import jdk.internal.org.objectweb.asm.ClassWriter;
+import jdk.internal.org.objectweb.asm.FieldVisitor;
+import jdk.internal.org.objectweb.asm.Label;
+import jdk.internal.org.objectweb.asm.MethodVisitor;
+import jdk.internal.org.objectweb.asm.Opcodes;
+import jdk.test.lib.Pair;
+import jdk.test.lib.jittester.BinaryOperator;
+import jdk.test.lib.jittester.Block;
+import jdk.test.lib.jittester.BuiltInType;
+import jdk.test.lib.jittester.Break;
+import jdk.test.lib.jittester.CastOperator;
+import jdk.test.lib.jittester.CatchBlock;
+import jdk.test.lib.jittester.Continue;
+import jdk.test.lib.jittester.Declaration;
+import jdk.test.lib.jittester.IRNode;
+import jdk.test.lib.jittester.If;
+import jdk.test.lib.jittester.Initialization;
+import jdk.test.lib.jittester.Literal;
+import jdk.test.lib.jittester.LocalVariable;
+import jdk.test.lib.jittester.NonStaticMemberVariable;
+import jdk.test.lib.jittester.Nothing;
+import jdk.test.lib.jittester.Operator;
+import jdk.test.lib.jittester.OperatorKind;
+import jdk.test.lib.jittester.PrintVariables;
+import jdk.test.lib.jittester.ProductionParams;
+import jdk.test.lib.jittester.Statement;
+import jdk.test.lib.jittester.StaticMemberVariable;
+import jdk.test.lib.jittester.Switch;
+import jdk.test.lib.jittester.Symbol;
+import jdk.test.lib.jittester.TernaryOperator;
+import jdk.test.lib.jittester.Throw;
+import jdk.test.lib.jittester.TryCatchBlock;
+import jdk.test.lib.jittester.Type;
+import jdk.test.lib.jittester.TypeList;
+import jdk.test.lib.jittester.UnaryOperator;
+import jdk.test.lib.jittester.VariableBase;
+import jdk.test.lib.jittester.VariableDeclaration;
+import jdk.test.lib.jittester.VariableDeclarationBlock;
+import jdk.test.lib.jittester.VariableInfo;
+import jdk.test.lib.jittester.VariableInitialization;
+import jdk.test.lib.jittester.arrays.ArrayCreation;
+import jdk.test.lib.jittester.arrays.ArrayElement;
+import jdk.test.lib.jittester.arrays.ArrayExtraction;
+import jdk.test.lib.jittester.classes.ClassDefinitionBlock;
+import jdk.test.lib.jittester.classes.Interface;
+import jdk.test.lib.jittester.classes.Klass;
+import jdk.test.lib.jittester.classes.MainKlass;
+import jdk.test.lib.jittester.functions.ArgumentDeclaration;
+import jdk.test.lib.jittester.functions.ConstructorDefinition;
+import jdk.test.lib.jittester.functions.ConstructorDefinitionBlock;
+import jdk.test.lib.jittester.functions.Function;
+import jdk.test.lib.jittester.functions.FunctionDeclaration;
+import jdk.test.lib.jittester.functions.FunctionDeclarationBlock;
+import jdk.test.lib.jittester.functions.FunctionDefinition;
+import jdk.test.lib.jittester.functions.FunctionDefinitionBlock;
+import jdk.test.lib.jittester.functions.FunctionInfo;
+import jdk.test.lib.jittester.functions.FunctionRedefinition;
+import jdk.test.lib.jittester.functions.FunctionRedefinitionBlock;
+import jdk.test.lib.jittester.functions.Return;
+import jdk.test.lib.jittester.functions.StaticConstructorDefinition;
+import jdk.test.lib.jittester.loops.CounterInitializer;
+import jdk.test.lib.jittester.loops.CounterManipulator;
+import jdk.test.lib.jittester.loops.DoWhile;
+import jdk.test.lib.jittester.loops.For;
+import jdk.test.lib.jittester.loops.Loop;
+import jdk.test.lib.jittester.loops.LoopingCondition;
+import jdk.test.lib.jittester.loops.While;
+import jdk.test.lib.jittester.types.TypeArray;
+import jdk.test.lib.jittester.types.TypeKlass;
+import jdk.test.lib.jittester.utils.FixedTrees;
+import jdk.test.lib.jittester.utils.PseudoRandom;
+
+public class ByteCodeVisitor implements Visitor<byte[]> {
+    private final GeneratedClassesContext context = new GeneratedClassesContext();
+    private final byte[] EMPTY_BYTE_ARRAY = new byte[0];
+    private final int CLASS_WRITER_FLAGS = ContextDependedClassWriter.COMPUTE_MAXS | ContextDependedClassWriter.COMPUTE_FRAMES;
+    private final HashMap<String, ContextDependedClassWriter> classWriters = new HashMap<>();
+    private MethodVisitor currentMV;
+    private TypeKlass currentClass;
+    private final LocalVariablesTable locals = new LocalVariablesTable();
+    private final Deque<Label> endLabels = new ArrayDeque<>();
+    private final Deque<Label> beginLabels = new ArrayDeque<>();
+
+    @Override
+    public byte[] visit(ArgumentDeclaration node) {
+        /* handled by FunctionDefinition for ByteCodeVisitor */
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(ArrayCreation node) {
+        int dimensions = node.getDimensionsCount();
+        TypeArray arrayType = node.getArrayType();
+        Type basicType = arrayType.type;
+        for (IRNode child : node.getChildren()) {
+            child.accept(this);
+        }
+        if (dimensions == 1) {
+            if (basicType.equals(TypeList.BOOLEAN)) {
+                currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_BOOLEAN);
+            } else if (basicType.equals(TypeList.BYTE)) {
+                currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_BYTE);
+            } else if (basicType.equals(TypeList.CHAR)) {
+                currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_CHAR);
+            } else if (basicType.equals(TypeList.SHORT)) {
+                currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_SHORT);
+            } else if (basicType.equals(TypeList.INT)) {
+                currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_INT);
+            } else if (basicType.equals(TypeList.LONG)) {
+                currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_LONG);
+            } else if (basicType.equals(TypeList.FLOAT)) {
+                currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_FLOAT);
+            } else if (basicType.equals(TypeList.DOUBLE)) {
+                currentMV.visitIntInsn(Opcodes.NEWARRAY, Opcodes.T_DOUBLE);
+            } else {
+                currentMV.visitTypeInsn(Opcodes.ANEWARRAY, asInternalName(basicType.getName()));
+            }
+        } else {
+            currentMV.visitMultiANewArrayInsn(new String(arrayType.accept(this)), dimensions);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(ArrayElement node) {
+        node.getChild(0).accept(this);
+        int dimensions = node.getChildren().size() - 1;
+        Type resultType = node.getResultType();
+        for (int i = 1; i < dimensions; i++) {
+            node.getChild(i).accept(this);
+            currentMV.visitInsn(Opcodes.AALOAD);
+        }
+        node.getChild(dimensions).accept(this);
+        if (resultType.equals(TypeList.BOOLEAN) || resultType.equals(TypeList.BYTE)) {
+            currentMV.visitInsn(Opcodes.BALOAD);
+        } else if (resultType.equals(TypeList.CHAR)) {
+            currentMV.visitInsn(Opcodes.CALOAD);
+        } else if (resultType.equals(TypeList.SHORT)) {
+            currentMV.visitInsn(Opcodes.SALOAD);
+        } else if (resultType.equals(TypeList.INT)) {
+            currentMV.visitInsn(Opcodes.IALOAD);
+        } else if (resultType.equals(TypeList.LONG)) {
+            currentMV.visitInsn(Opcodes.LALOAD);
+        } else if (resultType.equals(TypeList.FLOAT)) {
+            currentMV.visitInsn(Opcodes.FALOAD);
+        } else if (resultType.equals(TypeList.DOUBLE)) {
+            currentMV.visitInsn(Opcodes.DALOAD);
+        } else {
+            currentMV.visitInsn(Opcodes.AALOAD);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(ArrayExtraction node) {
+        node.getChild(0).accept(this);
+        int dimensions = node.getChildren().size() - 1;
+        Type resultType = node.getResultType();
+        for (int i = 1; i < dimensions; i++) {
+            node.getChild(i).accept(this);
+            currentMV.visitInsn(Opcodes.AALOAD);
+        }
+        node.getChild(dimensions).accept(this);
+        if (resultType.equals(TypeList.BOOLEAN) || resultType.equals(TypeList.BYTE)) {
+            currentMV.visitInsn(Opcodes.BALOAD);
+        } else if (resultType.equals(TypeList.CHAR)) {
+            currentMV.visitInsn(Opcodes.CALOAD);
+        } else if (resultType.equals(TypeList.SHORT)) {
+            currentMV.visitInsn(Opcodes.SALOAD);
+        } else if (resultType.equals(TypeList.INT)) {
+            currentMV.visitInsn(Opcodes.IALOAD);
+        } else if (resultType.equals(TypeList.LONG)) {
+            currentMV.visitInsn(Opcodes.LALOAD);
+        } else if (resultType.equals(TypeList.FLOAT)) {
+            currentMV.visitInsn(Opcodes.FALOAD);
+        } else if (resultType.equals(TypeList.DOUBLE)) {
+            currentMV.visitInsn(Opcodes.DALOAD);
+        } else {
+            currentMV.visitInsn(Opcodes.AALOAD);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(BinaryOperator node) {
+        OperatorKind kind = node.getOperationKind();
+        IRNode left = node.getChild(Operator.Order.LEFT.ordinal());
+        IRNode right = node.getChild(Operator.Order.RIGHT.ordinal());
+        Type resultType = node.getResultType();
+        if (left == null || right == null) {
+            return EMPTY_BYTE_ARRAY;
+        }
+        boolean needTypeConversion = false;
+        boolean convertRightArg = false;
+        Type leftType = left.getResultType();
+        Type rightType = right.getResultType();
+        if (!leftType.equals(rightType) && leftType instanceof BuiltInType
+                && rightType instanceof BuiltInType
+                && kind != OperatorKind.SAR && kind != OperatorKind.SHL
+                && kind != OperatorKind.SHR && kind != OperatorKind.ASSIGN
+                && kind != OperatorKind.AND && kind != OperatorKind.OR) {
+            needTypeConversion = true;
+            BuiltInType leftBuiltIn = (BuiltInType) leftType;
+            BuiltInType rightBuiltIn = (BuiltInType) rightType;
+            convertRightArg = leftBuiltIn.isMoreCapaciousThan(rightBuiltIn);
+        }
+        Type mostCapacious = convertRightArg ? leftType : rightType;
+        if (!rightType.equals(TypeList.INT)
+                && (kind == OperatorKind.SHL || kind == OperatorKind.SHR
+                || kind == OperatorKind.SAR)) {
+            left.accept(this);
+            right.accept(this);
+            convertTopType(rightType, TypeList.INT);
+        } else if (kind != OperatorKind.ASSIGN && kind != OperatorKind.OR
+                && kind != OperatorKind.AND && kind != OperatorKind.COMPOUND_ADD
+                && kind != OperatorKind.COMPOUND_AND && kind != OperatorKind.COMPOUND_DIV
+                && kind != OperatorKind.COMPOUND_MOD && kind != OperatorKind.COMPOUND_MUL
+                && kind != OperatorKind.COMPOUND_OR && kind != OperatorKind.COMPOUND_SAR
+                && kind != OperatorKind.COMPOUND_SHL && kind != OperatorKind.COMPOUND_SHR
+                && kind != OperatorKind.COMPOUND_SUB && kind != OperatorKind.COMPOUND_XOR
+                && kind != OperatorKind.STRADD) {
+                /* "assign", "and", "or", concat and all compound operators are
+                    handled differently and shouldn't just place left and right
+                    operands on stack */
+            left.accept(this);
+            if (needTypeConversion && !convertRightArg) {
+                convertTopType(leftType, rightType);
+            }
+            right.accept(this);
+            if (needTypeConversion && convertRightArg) {
+                convertTopType(rightType, leftType);
+            }
+        }
+        switch (kind) {
+            case ASSIGN:
+                VariableInfo vi = ((VariableBase)left).getVariableInfo();
+                Type varType = vi.type;
+                if (left instanceof LocalVariable) {
+                    right.accept(this);
+                    convertTopType(rightType, leftType);
+                    int index = locals.getLocalIndex(vi);
+                    if (varType.equals(TypeList.LONG)) {
+                        currentMV.visitVarInsn(Opcodes.LSTORE, index);
+                        currentMV.visitVarInsn(Opcodes.LLOAD, index);
+                    } else if (varType.equals(TypeList.DOUBLE)) {
+                        currentMV.visitVarInsn(Opcodes.DSTORE, index);
+                        currentMV.visitVarInsn(Opcodes.DLOAD, index);
+                    } else if (varType.equals(TypeList.FLOAT)) {
+                        currentMV.visitVarInsn(Opcodes.FSTORE, index);
+                        currentMV.visitVarInsn(Opcodes.FLOAD, index);
+                    } else if (varType instanceof TypeKlass) {
+                        currentMV.visitVarInsn(Opcodes.ASTORE, index);
+                        currentMV.visitVarInsn(Opcodes.ALOAD, index);
+                    } else {
+                        currentMV.visitVarInsn(Opcodes.ISTORE, index);
+                        currentMV.visitVarInsn(Opcodes.ILOAD, index);
+                    }
+                } else if (left instanceof StaticMemberVariable) {
+                    right.accept(this);
+                    convertTopType(rightType, leftType);
+                    String typeDescr = new String(vi.type.accept(this));
+                    String ownerName = asInternalName(vi.getOwner().getName());
+                    currentMV.visitFieldInsn(Opcodes.PUTSTATIC, ownerName,
+                            vi.name, typeDescr);
+                    currentMV.visitFieldInsn(Opcodes.GETSTATIC, ownerName,
+                            vi.name, typeDescr);
+                } else if (left instanceof NonStaticMemberVariable) {
+                    // put object to stack for putfield
+                    left.getChild(0).accept(this);
+                    // put object to stack for getfield
+                    currentMV.visitInsn(Opcodes.DUP);
+                    right.accept(this);
+                    convertTopType(rightType, leftType);
+                    String typeDescr = new String(vi.type.accept(this));
+                    String ownerName = asInternalName(vi.getOwner().getName());
+                    currentMV.visitFieldInsn(Opcodes.PUTFIELD, ownerName,
+                            vi.name, typeDescr);
+                    currentMV.visitFieldInsn(Opcodes.GETFIELD, ownerName,
+                            vi.name, typeDescr);
+                } else {
+                    throw new IllegalArgumentException("illegal left operand : "
+                            + left + "("+left.getClass()+")");
+                }
+                break;
+            case OR:
+                generateBasicLogicOperator(Opcodes.IFNE, false, left, right);
+                break;
+            case AND:
+                generateBasicLogicOperator(Opcodes.IFEQ, true,  left, right);
+                break;
+            case BIT_OR:
+                if (mostCapacious.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LOR);
+                } else {
+                    currentMV.visitInsn(Opcodes.IOR);
+                }
+                break;
+            case BIT_XOR:
+                if (mostCapacious.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LXOR);
+                } else {
+                    currentMV.visitInsn(Opcodes.IXOR);
+                }
+                break;
+            case BIT_AND:
+                if (mostCapacious.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LAND);
+                } else {
+                    currentMV.visitInsn(Opcodes.IAND);
+                }
+                break;
+            case EQ:
+                generateCmpBasedCode(mostCapacious, Opcodes.IFEQ, Opcodes.IF_ICMPEQ);
+                break;
+            case NE:
+                generateCmpBasedCode(mostCapacious, Opcodes.IFNE, Opcodes.IF_ICMPNE);
+                break;
+            case GT:
+                generateCmpBasedCode(mostCapacious, Opcodes.IFGT, Opcodes.IF_ICMPGT);
+                break;
+            case LT:
+                generateCmpBasedCode(mostCapacious, Opcodes.IFLT, Opcodes.IF_ICMPLT);
+                break;
+            case GE:
+                generateCmpBasedCode(mostCapacious, Opcodes.IFGE, Opcodes.IF_ICMPGE);
+                break;
+            case LE:
+                generateCmpBasedCode(mostCapacious, Opcodes.IFLE, Opcodes.IF_ICMPLE);
+                break;
+            case SHR:
+                if (leftType.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LSHR);
+                } else {
+                    currentMV.visitInsn(Opcodes.ISHR);
+                }
+                break;
+            case SHL:
+                if (leftType.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LSHL);
+                } else {
+                    currentMV.visitInsn(Opcodes.ISHL);
+                }
+                break;
+            case SAR:
+                if (leftType.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LUSHR);
+                } else {
+                    currentMV.visitInsn(Opcodes.IUSHR);
+                }
+                break;
+            case STRADD:
+                // we use String::valueOf to change null to "null"
+                left.accept(this);
+                currentMV.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/String", "valueOf",
+                        "(Ljava/lang/Object;)Ljava/lang/String;", false /* not interface */);
+                right.accept(this);
+                currentMV.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/String", "valueOf",
+                        "(Ljava/lang/Object;)Ljava/lang/String;", false /* not interface */);
+                currentMV.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/String", "concat",
+                        "(Ljava/lang/String;)Ljava/lang/String;", false /* not interface */);
+                break;
+            case ADD:
+                if (mostCapacious.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LADD);
+                } else if (mostCapacious.equals(TypeList.DOUBLE)) {
+                    currentMV.visitInsn(Opcodes.DADD);
+                } else if (mostCapacious.equals(TypeList.FLOAT)) {
+                    currentMV.visitInsn(Opcodes.FADD);
+                } else {
+                    currentMV.visitInsn(Opcodes.IADD);
+                }
+                break;
+            case SUB:
+                if (mostCapacious.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LSUB);
+                } else if (mostCapacious.equals(TypeList.DOUBLE)) {
+                    currentMV.visitInsn(Opcodes.DSUB);
+                } else if (mostCapacious.equals(TypeList.FLOAT)) {
+                    currentMV.visitInsn(Opcodes.FSUB);
+                } else {
+                    currentMV.visitInsn(Opcodes.ISUB);
+                }
+                break;
+            case MUL:
+                if (mostCapacious.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LMUL);
+                } else if (mostCapacious.equals(TypeList.DOUBLE)) {
+                    currentMV.visitInsn(Opcodes.DMUL);
+                } else if (mostCapacious.equals(TypeList.FLOAT)) {
+                    currentMV.visitInsn(Opcodes.FMUL);
+                } else {
+                    currentMV.visitInsn(Opcodes.IMUL);
+                }
+                break;
+            case DIV:
+                if (mostCapacious.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LDIV);
+                } else if (mostCapacious.equals(TypeList.DOUBLE)) {
+                    currentMV.visitInsn(Opcodes.DDIV);
+                } else if (mostCapacious.equals(TypeList.FLOAT)) {
+                    currentMV.visitInsn(Opcodes.FDIV);
+                } else {
+                    currentMV.visitInsn(Opcodes.IDIV);
+                }
+                break;
+            case MOD:
+                if (mostCapacious.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LREM);
+                } else if (mostCapacious.equals(TypeList.DOUBLE)) {
+                    currentMV.visitInsn(Opcodes.DREM);
+                } else if (mostCapacious.equals(TypeList.FLOAT)) {
+                    currentMV.visitInsn(Opcodes.FREM);
+                } else {
+                    currentMV.visitInsn(Opcodes.IREM);
+                }
+                break;
+            case COMPOUND_ADD:
+                lowerCompoundBinaryOperator("java.lang.String".equals(leftType.getName())
+                        ? OperatorKind.STRADD : OperatorKind.ADD, node);
+                break;
+            case COMPOUND_SUB:
+                lowerCompoundBinaryOperator(OperatorKind.SUB, node);
+                break;
+            case COMPOUND_MUL:
+                lowerCompoundBinaryOperator(OperatorKind.MUL, node);
+                break;
+            case COMPOUND_DIV:
+                lowerCompoundBinaryOperator(OperatorKind.DIV, node);
+                break;
+            case COMPOUND_MOD:
+                lowerCompoundBinaryOperator(OperatorKind.MOD, node);
+                break;
+            case COMPOUND_AND:
+                lowerCompoundBinaryOperator(leftType.equals(TypeList.BOOLEAN)
+                        ? OperatorKind.AND : OperatorKind.BIT_AND, node);
+                break;
+            case COMPOUND_OR:
+                lowerCompoundBinaryOperator(leftType.equals(TypeList.BOOLEAN)
+                        ? OperatorKind.OR : OperatorKind.BIT_OR, node);
+                break;
+            case COMPOUND_XOR:
+                lowerCompoundBinaryOperator(OperatorKind.BIT_XOR, node);
+                break;
+            case COMPOUND_SHR:
+                lowerCompoundBinaryOperator(OperatorKind.SHR, node);
+                break;
+            case COMPOUND_SHL:
+                lowerCompoundBinaryOperator(OperatorKind.SHL, node);
+                break;
+            case COMPOUND_SAR:
+                lowerCompoundBinaryOperator(OperatorKind.SAR, node);
+                break;
+            default:
+                throw new Error("Unsupported binary operator");
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    private static int tmpObject;
+    private void lowerCompoundBinaryOperator(OperatorKind kind, IRNode node) {
+        IRNode left = node.getChild(Operator.Order.LEFT.ordinal());
+        IRNode right = node.getChild(Operator.Order.RIGHT.ordinal());
+
+        if (left instanceof NonStaticMemberVariable) {
+            NonStaticMemberVariable var = (NonStaticMemberVariable) left;
+            IRNode holder = var.getChild(0);
+            Type type = holder.getResultType();
+            VariableInfo tmpInfo = new VariableInfo("tmpObject_" + tmpObject++,
+                    currentClass, type, VariableInfo.LOCAL);
+            new Statement(new VariableInitialization(tmpInfo, holder), true).accept(this);
+            left = new NonStaticMemberVariable(new LocalVariable(tmpInfo), var.getVariableInfo());
+        }
+        Type leftType = left.getResultType();
+        Type rightType = right.getResultType();
+        Type resultType = leftType;
+        if (leftType instanceof BuiltInType && rightType instanceof BuiltInType) {
+            if (kind != OperatorKind.SHL && kind != OperatorKind.SHR && kind != OperatorKind.SAR
+                    && ((BuiltInType) rightType).isMoreCapaciousThan((BuiltInType) leftType)) {
+                resultType = rightType;
+            }
+        }
+        IRNode result = new CastOperator(leftType,
+                new BinaryOperator(kind, resultType, left, right));
+        new BinaryOperator(OperatorKind.ASSIGN, leftType, left, result).accept(this);
+    }
+
+    private void generateBasicLogicOperator(int ifOpcode, boolean retTrueFirst, IRNode left,
+            IRNode right) {
+        Label secondCase = new Label();
+        Label endLabel = new Label();
+        left.accept(this);
+        currentMV.visitJumpInsn(ifOpcode, secondCase);
+        right.accept(this);
+        currentMV.visitJumpInsn(ifOpcode, secondCase);
+        currentMV.visitInsn(retTrueFirst ? Opcodes.ICONST_1 : Opcodes.ICONST_0);
+        currentMV.visitJumpInsn(Opcodes.GOTO, endLabel);
+        currentMV.visitLabel(secondCase);
+        currentMV.visitInsn(retTrueFirst ? Opcodes.ICONST_0 : Opcodes.ICONST_1);
+        currentMV.visitLabel(endLabel);
+    }
+
+    private void generateCmpBasedCode(Type type, int nonIntOpcode, int intOpcode) {
+        boolean useNonIntOpcode = false;
+        if (type.equals(TypeList.LONG) || type.equals(TypeList.FLOAT)
+                || type.equals(TypeList.DOUBLE)) {
+            if (type.equals(TypeList.LONG)) {
+                currentMV.visitInsn(Opcodes.LCMP);
+            } else if (type.equals(TypeList.FLOAT)) {
+                currentMV.visitInsn(Opcodes.FCMPL);
+            } else {
+                currentMV.visitInsn(Opcodes.DCMPL);
+            }
+            useNonIntOpcode = true;
+        }
+        int opcodeToUse;
+        if (!useNonIntOpcode) {
+            if (type instanceof TypeKlass) {
+                if (intOpcode == Opcodes.IF_ICMPEQ) {
+                    opcodeToUse = Opcodes.IF_ACMPEQ;
+                } else if (intOpcode == Opcodes.IF_ICMPNE) {
+                    opcodeToUse = Opcodes.IF_ACMPNE;
+                } else {
+                    throw new Error("Can't compare references");
+                }
+            } else {
+                opcodeToUse = intOpcode;
+            }
+        } else {
+            opcodeToUse = nonIntOpcode;
+        }
+        Label retTrue = new Label();
+        Label end = new Label();
+        currentMV.visitJumpInsn(opcodeToUse, retTrue);
+        currentMV.visitInsn(Opcodes.ICONST_0);
+        currentMV.visitJumpInsn(Opcodes.GOTO, end);
+        currentMV.visitLabel(retTrue);
+        currentMV.visitInsn(Opcodes.ICONST_1);
+        currentMV.visitLabel(end);
+    }
+
+    /*
+     * Converts top-stack element from one builtin type to another
+     */
+    private void convertTopType(Type from, Type to) {
+        if (!(from instanceof BuiltInType) || !(to instanceof BuiltInType) || from.equals(to)) {
+            return; // skip
+        }
+        boolean castedToInt = false;
+        if (from.equals(TypeList.FLOAT)) {
+            if (to.equals(TypeList.DOUBLE)) {
+                currentMV.visitInsn(Opcodes.F2D);
+            } else if (to.equals(TypeList.LONG)) {
+                currentMV.visitInsn(Opcodes.F2L);
+            } else {
+                currentMV.visitInsn(Opcodes.F2I);
+                castedToInt = true;
+            }
+        } else if (from.equals(TypeList.DOUBLE)) {
+            if (to.equals(TypeList.FLOAT)) {
+                currentMV.visitInsn(Opcodes.D2F);
+            } else if (to.equals(TypeList.LONG)) {
+                currentMV.visitInsn(Opcodes.D2L);
+            } else {
+                currentMV.visitInsn(Opcodes.D2I);
+                castedToInt = true;
+            }
+        } else if (from.equals(TypeList.LONG)) {
+            if (to.equals(TypeList.DOUBLE)) {
+                currentMV.visitInsn(Opcodes.L2D);
+            } else if (to.equals(TypeList.FLOAT)) {
+                currentMV.visitInsn(Opcodes.L2F);
+            } else {
+                currentMV.visitInsn(Opcodes.L2I);
+                castedToInt = true;
+            }
+        } else {
+            if (to.equals(TypeList.BYTE)) {
+                currentMV.visitInsn(Opcodes.I2B);
+            } else if (to.equals(TypeList.CHAR)) {
+                currentMV.visitInsn(Opcodes.I2C);
+            } else if (to.equals(TypeList.SHORT)) {
+                currentMV.visitInsn(Opcodes.I2S);
+            } else if (to.equals(TypeList.LONG)) {
+                currentMV.visitInsn(Opcodes.I2L);
+            } else if (to.equals(TypeList.FLOAT)) {
+                currentMV.visitInsn(Opcodes.I2F);
+            } else if (to.equals(TypeList.DOUBLE)) {
+                currentMV.visitInsn(Opcodes.I2D);
+            }
+        }
+        if (castedToInt) {
+            if (to.equals(TypeList.BYTE)) {
+                currentMV.visitInsn(Opcodes.I2B);
+            } else if (to.equals(TypeList.CHAR)) {
+                currentMV.visitInsn(Opcodes.I2C);
+            } else if (to.equals(TypeList.SHORT)) {
+                currentMV.visitInsn(Opcodes.I2S);
+            }
+        }
+    }
+
+    @Override
+    public byte[] visit(Block node) {
+        return iterateBlock(node);
+    }
+
+    @Override
+    public byte[] visit(Break node) {
+        Label label = endLabels.peek();
+        if (label != null) {
+            currentMV.visitJumpInsn(Opcodes.GOTO, label);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(CastOperator node) {
+        IRNode expression = node.getChild(0);
+        expression.accept(this);
+        Type to = node.getResultType();
+        Type from = expression.getResultType();
+        // TODO boxing/unboxing
+        if (!TypeList.isBuiltIn(to) || !TypeList.isBuiltIn(from)) {
+            // class cast
+            currentMV.visitTypeInsn(Opcodes.CHECKCAST, asInternalName(to.getName()));
+        } else {
+            convertTopType(from, to);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(CatchBlock node) {
+        Type type = node.throwables.get(0);
+        VariableInfo exInfo = new VariableInfo("ex", currentClass,
+                type, VariableInfo.LOCAL);
+        int index = locals.getLocalIndex(exInfo);
+        currentMV.visitVarInsn(Opcodes.ASTORE, index);
+        node.getChild(0).accept(this);
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(ClassDefinitionBlock node) {
+        return iterateBlock(node);
+    }
+
+    @Override
+    public byte[] visit(ConstructorDefinition node) {
+        FunctionInfo info = node.getFunctionInfo();
+        String ownerName = node.getOwner().getName();
+        TypeKlass parentClass = currentClass.getParent();
+        ContextDependedClassWriter cw = classWriters.get(ownerName);
+
+        String descriptor = getDescriptor(node, 1, "V");
+        currentMV = cw.visitMethod(asAccessFlags(info), "<init>", descriptor, null, null);
+        currentMV.visitVarInsn(Opcodes.ALOAD, 0);
+        currentMV.visitMethodInsn(Opcodes.INVOKESPECIAL,
+                parentClass != null ? asInternalName(parentClass.getName()) : "java/lang/Object",
+                "<init>", "()V", false);
+        locals.initConstructorArguments(node.getOwner(), info);
+        // TODO: add datamemebers as child to all ctors
+        generateDataMembers(node.getParent().getParent().getChild(Klass.KlassPart.DATA_MEMBERS.ordinal()));
+        IRNode body = node.getChild(0);
+        body.accept(this);
+        currentMV.visitInsn(Opcodes.RETURN);
+        currentMV.visitMaxs(0, 0);
+        currentMV.visitEnd();
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    private void generateDataMembers(IRNode node) {
+        // TODO shouldn't we skip declaration?
+        if (node != null) {
+            node.accept(this);
+        }
+    }
+
+    @Override
+    public byte[] visit(ConstructorDefinitionBlock node) {
+        return iterateBlock(node);
+    }
+
+    @Override
+    public byte[] visit(Continue node) {
+        Label label = beginLabels.peek();
+        if (label != null) {
+            currentMV.visitJumpInsn(Opcodes.GOTO, label);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(CounterInitializer node) {
+        visitLocalVar(node);
+        emitPop(node.getVariableInfo().type);
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    private byte[] visitLocalVar(Initialization node) {
+        VariableInfo vi = node.getVariableInfo();
+        int index = locals.addLocal(vi);
+        int store;
+        node.getChild(0).accept(this); // place initialization expression on stack
+        emitDup(vi.type);
+        if (vi.type instanceof TypeKlass) {
+            store = Opcodes.ASTORE;
+        } else if (vi.type.equals(TypeList.DOUBLE)) {
+            store = Opcodes.DSTORE;
+        } else if (vi.type.equals(TypeList.LONG)) {
+            store = Opcodes.LSTORE;
+        } else if (vi.type.equals(TypeList.FLOAT)) {
+            store = Opcodes.FSTORE;
+        } else {
+            store = Opcodes.ISTORE;
+        }
+        currentMV.visitVarInsn(store, index);
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(CounterManipulator node) {
+        return node.getChild(0).accept(this);
+    }
+
+    @Override
+    public byte[] visit(Declaration node) {
+        IRNode child = node.getChild(0);
+        child.accept(this);
+        if (child instanceof Initialization) {
+            emitPop(((Initialization) child).getVariableInfo().type);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(DoWhile node) {
+        Loop loop = node.getLoop();
+        loop.initialization.accept(this);
+        node.getChild(DoWhile.DoWhilePart.HEADER.ordinal()).accept(this);
+        Label currentLoopBegin = new Label();
+        beginLabels.push(currentLoopBegin);
+        Label currentLoopEnd = new Label();
+        endLabels.push(currentLoopEnd);
+        currentMV.visitLabel(currentLoopBegin);
+        node.getChild(DoWhile.DoWhilePart.BODY1.ordinal()).accept(this);
+        loop.manipulator.accept(this);
+        node.getChild(DoWhile.DoWhilePart.BODY2.ordinal()).accept(this);
+        loop.condition.accept(this);
+        assert loop.condition.getResultType() == TypeList.BOOLEAN;
+        currentMV.visitJumpInsn(Opcodes.IFEQ, currentLoopBegin);
+        currentMV.visitLabel(currentLoopEnd);
+        Label a = beginLabels.pop();
+        assert currentLoopBegin == a;
+        a = endLabels.pop();
+        assert currentLoopEnd == a;
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(For node) {
+        Loop loop = node.getLoop();
+        loop.initialization.accept(this);
+        node.getChild(For.ForPart.HEADER.ordinal()).accept(this);
+        node.getChild(For.ForPart.STATEMENT1.ordinal()).accept(this);
+        Label currentLoopBegin = new Label();
+        beginLabels.push(currentLoopBegin);
+        currentMV.visitLabel(currentLoopBegin);
+        loop.condition.accept(this);
+        assert loop.condition.getResultType() == TypeList.BOOLEAN;
+        Label currentLoopEnd = new Label();
+        endLabels.push(currentLoopEnd);
+        currentMV.visitJumpInsn(Opcodes.IFEQ, currentLoopEnd);
+        node.getChild(For.ForPart.STATEMENT2.ordinal()).accept(this);
+        node.getChild(For.ForPart.BODY1.ordinal()).accept(this);
+        loop.manipulator.accept(this);
+        node.getChild(For.ForPart.BODY2.ordinal()).accept(this);
+        node.getChild(For.ForPart.BODY3.ordinal()).accept(this);
+        currentMV.visitJumpInsn(Opcodes.GOTO, currentLoopBegin);
+        currentMV.visitLabel(currentLoopEnd);
+        Label a = beginLabels.pop();
+        assert currentLoopBegin == a;
+        a = endLabels.pop();
+        assert currentLoopEnd == a;
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(Function node) {
+        FunctionInfo info = node.getValue();
+        boolean needInstance = !info.isStatic() && !info.isConstructor();
+        if (needInstance) {
+            node.getChild(0).accept(this); // placing instance on stack
+        }
+        // call itself with specific invoke*
+        String signature = info.argTypes.stream()
+                .skip(!needInstance ? 0 : 1)
+                .map(vi -> new String(vi.type.accept(this)))
+                .collect(Collectors.joining("", "(", ")"))
+                + (info.isConstructor() ? "V" : new String(node.getResultType().accept(this)));
+        int invokeCode = Opcodes.INVOKEVIRTUAL;
+        if (info.isStatic()) {
+            invokeCode = Opcodes.INVOKESTATIC;
+        } else if (info.isConstructor() || info.isPrivate()) {
+            // TODO : superclass method invocation?
+            invokeCode = Opcodes.INVOKESPECIAL;
+        } else {
+            if (info.owner.isInterface()) {
+                invokeCode = Opcodes.INVOKEINTERFACE;
+            }
+        }
+        if (info.isConstructor()) {
+            currentMV.visitTypeInsn(Opcodes.NEW, asInternalName(info.owner.getName()));
+            currentMV.visitInsn(Opcodes.DUP);
+        }
+        // calculating parameters
+        node.getChildren().stream()
+                .skip(!needInstance ? 0 : 1)
+                .forEachOrdered(c -> c.accept(this));
+        currentMV.visitMethodInsn(invokeCode, asInternalName(info.owner.getName()),
+                info.isConstructor() ? "<init>" : info.name, signature,
+                invokeCode == Opcodes.INVOKEINTERFACE);
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(FunctionDeclaration node) {
+        FunctionInfo info = node.getFunctionInfo();
+        String ownerName = node.getOwner().getName();
+        ContextDependedClassWriter cw = classWriters.get(ownerName);
+        String returnType = new String(info.type.accept(this));
+
+        String descriptor = getDescriptor(node, 0, returnType);
+        currentMV = cw.visitMethod(asAccessFlags(info) + Opcodes.ACC_ABSTRACT,
+                info.name, descriptor, null, null);
+        currentMV.visitEnd();
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(FunctionDeclarationBlock node) {
+        return iterateBlock(node);
+    }
+
+    @Override
+    public byte[] visit(FunctionDefinition node) {
+        FunctionInfo info = node.getFunctionInfo();
+        String ownerName = node.getOwner().getName();
+        ContextDependedClassWriter cw = classWriters.get(ownerName);
+        String returnType = new String(info.type.accept(this));
+
+        String descriptor = getDescriptor(node, 2, returnType);
+        currentMV = cw.visitMethod(asAccessFlags(info), info.name, descriptor, null, null);
+        locals.initFunctionArguments(info);
+        IRNode body = node.getChild(0);
+        body.accept(this);
+        IRNode ret = node.getChild(1);
+        ret.accept(this);
+        currentMV.visitMaxs(0, 0);
+        currentMV.visitEnd();
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(FunctionDefinitionBlock node) {
+        return iterateBlock(node);
+    }
+
+    @Override
+    public byte[] visit(FunctionRedefinition node) {
+        FunctionInfo info = node.getFunctionInfo();
+        String ownerName = node.getOwner().getName();
+        ContextDependedClassWriter cw = classWriters.get(ownerName);
+        String returnType = new String(info.type.accept(this));
+        String descriptor = getDescriptor(node, 2, returnType);
+        currentMV = cw.visitMethod(asAccessFlags(info), info.name, descriptor, null, null);
+        locals.initFunctionArguments(info);
+        IRNode body = node.getChild(0);
+        body.accept(this);
+        IRNode ret = node.getChild(1);
+        ret.accept(this);
+        currentMV.visitMaxs(0, 0);
+        currentMV.visitEnd();
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(FunctionRedefinitionBlock node) {
+        return iterateBlock(node);
+    }
+
+    @Override
+    public byte[] visit(If node) {
+        IRNode conditionBlock = node.getChild(If.IfPart.CONDITION.ordinal());
+        // get the condition type to emit correct if
+        conditionBlock.accept(this);
+        generateIf(Opcodes.IFEQ, node.getChild(If.IfPart.THEN.ordinal()),
+                node.getChild(If.IfPart.ELSE.ordinal()));
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    /*
+     * Generates if block with then and else blocks for the given IF opcode
+     */
+    private void generateIf(int ifOpcode, IRNode thenBlock, IRNode elseBlock) {
+        Label elseLabel = new Label();
+        // if the opposite condition is met then go to the else statement
+        currentMV.visitJumpInsn(ifOpcode, elseLabel);
+        // write THEN block
+        thenBlock.accept(this);
+        if (elseBlock != null) {
+            // goto the end after THEN
+            Label endLabel = new Label();
+            currentMV.visitJumpInsn(Opcodes.GOTO, endLabel);
+            // ELSE block
+            currentMV.visitLabel(elseLabel);
+            elseBlock.accept(this);
+            currentMV.visitLabel(endLabel);
+        } else {
+            currentMV.visitLabel(elseLabel);
+        }
+    }
+
+    @Override
+    public byte[] visit(Initialization node) {
+        VariableInfo vi = node.getVariableInfo();
+        if (vi.isLocal()) {
+            return visitLocalVar(node);
+        }
+        String ownerName = vi.getOwner().getName();
+        ContextDependedClassWriter cw = classWriters.get(ownerName);
+        String typeName = new String(vi.type.accept(this));
+        // constant value used only for final static fields
+        FieldVisitor fw = cw.visitField(asAccessFlags(vi), vi.name,
+                typeName,
+                null /* Generic */,
+                null /* Constant value */);
+        fw.visitEnd(); // doesn't need visitAnnotation and visitAttribute
+        if (vi.isStatic()) {
+            node.getChild(0).accept(this); // put value to stack
+            emitDup(vi.type);
+            currentMV.visitFieldInsn(Opcodes.PUTSTATIC,
+                    asInternalName(vi.getOwner().getName()),
+                    vi.name,
+                    new String(vi.type.accept(this)));
+        } else {
+            // TODO : can it be another object?
+            currentMV.visitVarInsn(Opcodes.ALOAD, 0); // put this to stack
+            node.getChild(0).accept(this); // put value to stack
+            emitDupX1(vi.type);
+            currentMV.visitFieldInsn(Opcodes.PUTFIELD,
+                    asInternalName(vi.getOwner().getName()),
+                    vi.name,
+                    new String(vi.type.accept(this)));
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    private void emitDupX1(Type type) {
+        if (TypeList.DOUBLE.equals(type) || TypeList.LONG.equals(type)) {
+            currentMV.visitInsn(Opcodes.DUP2_X1);
+        } else if (!TypeList.VOID.equals(type)){
+            currentMV.visitInsn(Opcodes.DUP_X1);
+        }
+    }
+
+    private void emitDup(Type type) {
+        if (TypeList.DOUBLE.equals(type) || TypeList.LONG.equals(type)) {
+            currentMV.visitInsn(Opcodes.DUP2);
+        } else if (!TypeList.VOID.equals(type)){
+            currentMV.visitInsn(Opcodes.DUP);
+        }
+    }
+
+    @Override
+    public byte[] visit(Interface node) {
+        String name = node.getName();
+        ContextDependedClassWriter classWriter = new ContextDependedClassWriter(context, CLASS_WRITER_FLAGS);
+        classWriters.put(name, classWriter);
+        TypeKlass parentKlass = node.getParentKlass();
+        classWriter.visit(Opcodes.V1_8,
+                          Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE,
+                          asInternalName(name),
+                          null /* Generic */,
+                          "java/lang/Object",
+                          parentKlass == null ? null : new String[] {
+                                  asInternalName(parentKlass.getName())});
+        if (node.getChildren().size() > 0) {
+            node.getChild(0).accept(this);
+        }
+
+        classWriter.visitEnd();
+        byte[] byteCode = classWriter.toByteArray();
+        context.register(name, byteCode);
+        return byteCode;
+    }
+
+    @Override
+    public byte[] visit(Klass node) {
+        String name = node.getName();
+        TypeKlass prevClass = currentClass;
+        currentClass = node.getThisKlass();
+        ContextDependedClassWriter classWriter = new ContextDependedClassWriter(context, CLASS_WRITER_FLAGS);
+        classWriters.put(name, classWriter);
+        TypeKlass thisClass = node.getThisKlass();
+        TypeKlass parentClass = node.getParentKlass();
+        String[] interfaces = node.getInterfaces().stream()
+                .map(IRNode::getName)
+                .map(ByteCodeVisitor::asInternalName)
+                .toArray(String[]::new);
+        classWriter.visit(Opcodes.V1_8, asAccessFlags(thisClass),
+                asInternalName(name),
+                null /* Generic */,
+                parentClass != null ? asInternalName(parentClass.getName()) : "java/lang/Object",
+                interfaces);
+
+        IRNode constructors = node.getChild(Klass.KlassPart.CONSTRUCTORS.ordinal());
+        if (constructors != null) {
+            constructors.accept(this);
+        } else {
+            // generate default ctor
+            currentMV = classWriter.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
+            currentMV.visitVarInsn(Opcodes.ALOAD, 0);
+            currentMV.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+            locals.clear();
+            locals.addLocal(new VariableInfo("this", thisClass, thisClass, VariableInfo.NONE));
+            generateDataMembers(node.getChild(Klass.KlassPart.DATA_MEMBERS.ordinal()));
+            currentMV.visitInsn(Opcodes.RETURN);
+            currentMV.visitMaxs(0, 0);
+            currentMV.visitEnd();
+        }
+        IRNode redefinedFunctions = node.getChild(Klass.KlassPart.REDEFINED_FUNCTIONS.ordinal());
+        if (redefinedFunctions != null) {
+            redefinedFunctions.accept(this);
+        }
+        IRNode overridenFunctions = node.getChild(Klass.KlassPart.OVERRIDEN_FUNCTIONS.ordinal());
+        if (overridenFunctions != null) {
+            overridenFunctions.accept(this);
+        }
+        IRNode memberFunctions = node.getChild(Klass.KlassPart.MEMBER_FUNCTIONS.ordinal());
+        if (memberFunctions != null) {
+            memberFunctions.accept(this);
+        }
+        IRNode memberFunctionDecls = node.getChild(Klass.KlassPart.MEMBER_FUNCTIONS_DECLARATIONS.ordinal());
+        if (memberFunctionDecls != null) {
+            memberFunctionDecls.accept(this);
+        }
+        IRNode printVariables = node.getChild(Klass.KlassPart.PRINT_VARIABLES.ordinal());
+        if (printVariables != null) {
+            printVariables.accept(this);
+        }
+        classWriter.visitEnd();
+        byte[] byteCode = classWriter.toByteArray();
+        context.register(name, byteCode);
+        currentClass = prevClass;
+        return byteCode;
+    }
+
+    private void visitLiteral(boolean value) {
+        double chance = PseudoRandom.random();
+        if (chance < CONSTANT_INST_CHANCE) {
+            currentMV.visitInsn(value ? Opcodes.ICONST_1 : Opcodes.ICONST_0);
+        } else {
+            currentMV.visitIntInsn(Opcodes.BIPUSH, value ? 1 : 0);
+        }
+    }
+
+    private void visitLiteral(byte value) {
+        double chance = PseudoRandom.random();
+        if (chance < CONSTANT_INST_CHANCE && value > -2 && value < 6) {
+            currentMV.visitInsn(Opcodes.ICONST_0 + value);
+        } else {
+            currentMV.visitIntInsn(Opcodes.BIPUSH, value);
+        }
+    }
+
+    private void visitLiteral(short value) {
+        double chance = PseudoRandom.random();
+        if (chance < CONSTANT_INST_CHANCE && value > -2 && value < 6) {
+            currentMV.visitInsn(Opcodes.ICONST_0 + value);
+        } else {
+            currentMV.visitIntInsn(Opcodes.SIPUSH, value);
+        }
+    }
+
+    private void visitLiteral(char value) {
+        double chance = PseudoRandom.random();
+        if (chance < CONSTANT_INST_CHANCE && value < 6) {
+            currentMV.visitInsn(Opcodes.ICONST_0 + value);
+        } else {
+            // TODO : check for widechar/unicode
+            currentMV.visitIntInsn(Opcodes.BIPUSH, value);
+        }
+    }
+
+    private void visitLiteral(int value) {
+        double chance = PseudoRandom.random();
+        if (chance < CONSTANT_INST_CHANCE && value > -2 && value < 6) {
+            currentMV.visitInsn(Opcodes.ICONST_0 + value);
+        } else {
+            currentMV.visitLdcInsn(value);
+        }
+    }
+
+    private void visitLiteral(long value) {
+        double chance = PseudoRandom.random();
+        if (chance < CONSTANT_INST_CHANCE && value > -1 && value < 2) {
+            currentMV.visitInsn(Opcodes.LCONST_0 + (int)value);
+        } else {
+            currentMV.visitLdcInsn(value);
+        }
+    }
+
+    private void visitLiteral(float value) {
+        double chance = PseudoRandom.random();
+        if (chance < CONSTANT_INST_CHANCE && (value == 0.0f || value == 1.0f || value == 2.0f)) {
+            currentMV.visitInsn(Opcodes.FCONST_0 + (int)value);
+        } else {
+            currentMV.visitLdcInsn(value);
+        }
+    }
+
+    private void visitLiteral(double value) {
+        double chance = PseudoRandom.random();
+        if (chance < CONSTANT_INST_CHANCE && (value == 0.0 || value == 1.0)) {
+            currentMV.visitInsn(Opcodes.DCONST_0 + (int)value);
+        } else {
+            currentMV.visitLdcInsn(value);
+        }
+    }
+
+    @Override
+    public byte[] visit(Literal node) {
+        /*
+            ICONST_n (−1 ≤ n ≤ 5) <==> BIPUSH <n>
+            LCONST_n (0 ≤ n ≤ 1)
+            FCONST_n (0 ≤ n ≤ 2)
+            DCONST_n (0 ≤ n ≤ 1)
+            ACONST_NULL
+
+            BIPUSH b, −128 ≤ b < 127
+            SIPUSH s, −32768 ≤ s < 32767
+            LDC cst (int, float, long, double, String or Type)
+        */
+        Type type = node.getResultType();
+        double chance = PseudoRandom.random();
+        if (type.equals(TypeList.BOOLEAN)) {
+            visitLiteral(Boolean.valueOf(node.getValue().toString()));
+        } else if (type.equals(TypeList.BYTE)) {
+            visitLiteral(Byte.valueOf(node.getValue().toString()));
+        } else if (type.equals(TypeList.SHORT)) {
+            visitLiteral(Short.valueOf(node.getValue().toString()));
+        } else if (type.equals(TypeList.CHAR)) {
+            visitLiteral(node.getValue().toString().charAt(0));
+        } else if (type.equals(TypeList.INT)) {
+            visitLiteral(Integer.valueOf(node.getValue().toString()));
+        } else if (type.equals(TypeList.LONG)) {
+            visitLiteral(Long.valueOf(node.getValue().toString()));
+        } else if (type.equals(TypeList.FLOAT)) {
+            visitLiteral(Float.valueOf(node.getValue().toString()));
+        } else if (type.equals(TypeList.DOUBLE)) {
+            visitLiteral(Double.valueOf(node.getValue().toString()));
+        } else {
+            currentMV.visitLdcInsn(node.getValue());
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+    private static final double CONSTANT_INST_CHANCE = 0.5;
+
+    @Override
+    public byte[] visit(LocalVariable node) {
+        // This node is for "reading" only. Writing is handled in BinaryOperator visit(see ASSIGN)
+        VariableInfo vi = node.getVariableInfo();
+        Type varType = vi.type;
+        int index = locals.getLocalIndex(vi);
+        if (varType.equals(TypeList.LONG)) {
+            currentMV.visitVarInsn(Opcodes.LLOAD, index);
+        } else if (varType.equals(TypeList.DOUBLE)) {
+            currentMV.visitVarInsn(Opcodes.DLOAD, index);
+        } else if (varType.equals(TypeList.FLOAT)) {
+            currentMV.visitVarInsn(Opcodes.FLOAD, index);
+        } else if (varType instanceof TypeKlass) {
+            currentMV.visitVarInsn(Opcodes.ALOAD, index);
+        } else {
+            currentMV.visitVarInsn(Opcodes.ILOAD, index);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(LoopingCondition node) {
+        return node.getCondition().accept(this);
+    }
+
+    @Override
+    public byte[] visit(MainKlass node) {
+        TypeKlass prevClass = currentClass;
+        currentClass = node.getThisKlass();
+        String name = node.getName();
+        ContextDependedClassWriter mainClassWriter = new ContextDependedClassWriter(context, CLASS_WRITER_FLAGS);
+        classWriters.put(name, mainClassWriter);
+
+        TypeKlass thisClass = node.getThisKlass();
+        mainClassWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC,
+                asInternalName(name),
+                null /* Generic */,
+                "java/lang/Object",
+                null /* interfaces */);
+        // TODO: constructor for main class
+        currentMV = mainClassWriter.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
+        currentMV.visitVarInsn(Opcodes.ALOAD, 0);
+        currentMV.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        locals.clear();
+        locals.addLocal(new VariableInfo("this", thisClass, thisClass, VariableInfo.NONE));
+        generateDataMembers(node.getChild(MainKlass.MainKlassPart.DATA_MEMBERS.ordinal()));
+        currentMV.visitInsn(Opcodes.RETURN);
+        currentMV.visitMaxs(0, 0);
+        currentMV.visitEnd();
+
+        IRNode memberFunctions = node.getChild(MainKlass.MainKlassPart.MEMBER_FUNCTIONS.ordinal());
+        if (memberFunctions != null) {
+            memberFunctions.accept(this);
+        }
+        IRNode testFunction = node.getChild(MainKlass.MainKlassPart.TEST_FUNCTION.ordinal());
+        if (testFunction != null) {
+            currentMV = mainClassWriter.visitMethod(
+                    Opcodes.ACC_PRIVATE,
+                    "test",
+                    "()V",
+                    null,
+                    null);
+            locals.clear();
+            locals.addLocal(new VariableInfo("this", thisClass, thisClass, VariableInfo.NONE));
+            testFunction.accept(this);
+            currentMV.visitInsn(Opcodes.RETURN);
+            currentMV.visitMaxs(0, 0);
+            currentMV.visitEnd();
+        }
+        IRNode printVariables = node.getChild(MainKlass.MainKlassPart.PRINT_VARIABLES.ordinal());
+        if (printVariables != null) {
+            printVariables.accept(this);
+        }
+
+        mainClassWriter.visitEnd();
+
+        byte[] byteCode = mainClassWriter.toByteArray();
+        context.register(name, byteCode);
+        currentClass = prevClass;
+        return byteCode;
+    }
+
+    @Override
+    public byte[] visit(NonStaticMemberVariable node) {
+        // This node is for "reading" only. Writing is handled in BinaryOperator visit(see ASSIGN)
+        VariableInfo vi = node.getVariableInfo();
+        // put object to stack
+        node.getChild(0).accept(this);
+        currentMV.visitFieldInsn(Opcodes.GETFIELD, asInternalName(vi.getOwner().getName()), vi.name,
+                new String(vi.type.accept(this)));
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(Nothing node) {
+        // TODO : add randomness
+        currentMV.visitInsn(Opcodes.NOP);
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(PrintVariables node) {
+        return FixedTrees.printVariablesAsFunction(node).accept(this);
+    }
+
+    @Override
+    public byte[] visit(Return node) {
+        node.getExpression().accept(this);
+        Type result = node.getResultType();
+        if (result instanceof TypeKlass) {
+            currentMV.visitInsn(Opcodes.ARETURN);
+        } else if (result.equals(TypeList.VOID)) {
+            currentMV.visitInsn(Opcodes.RETURN);
+        } else if (result.equals(TypeList.DOUBLE)) {
+            currentMV.visitInsn(Opcodes.DRETURN);
+        } else if (result.equals(TypeList.FLOAT)) {
+            currentMV.visitInsn(Opcodes.FRETURN);
+        } else if (result.equals(TypeList.LONG)) {
+            currentMV.visitInsn(Opcodes.LRETURN);
+        } else {
+            currentMV.visitInsn(Opcodes.IRETURN);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(Statement node) {
+        IRNode child = node.getChild(0);
+        child.accept(this);
+        Type resultType = child.getResultType();
+        emitPop(resultType);
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    private void emitPop(Type resultType) {
+        if (resultType.equals(TypeList.LONG) || resultType.equals(TypeList.DOUBLE)) {
+            currentMV.visitInsn(Opcodes.POP2);
+        } else if (!resultType.equals(TypeList.VOID)) {
+            currentMV.visitInsn(Opcodes.POP);
+        }
+    }
+
+    @Override
+    public byte[] visit(StaticConstructorDefinition node) {
+        String ownerName = node.getOwner().getName();
+        ContextDependedClassWriter cw = classWriters.get(ownerName);
+        String descriptor = getDescriptor(node, 1, "V");
+        currentMV = cw.visitMethod(Opcodes.ACC_STATIC, "<clinit>", descriptor, null, null);
+        locals.clear();
+        IRNode body = node.getChild(0);
+        body.accept(this);
+        currentMV.visitInsn(Opcodes.RETURN);
+        currentMV.visitMaxs(0, 0);
+        currentMV.visitEnd();
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(StaticMemberVariable node) {
+        // This node is for "reading" only. Writing is handled in BinaryOperator visit(see ASSIGN)
+        VariableInfo vi = node.getVariableInfo();
+        currentMV.visitFieldInsn(Opcodes.GETSTATIC,
+                asInternalName(vi.getOwner().getName()),
+                vi.name,
+                new String(vi.type.accept(this)));
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(Switch node) {
+        node.getChild(0).accept(this);
+        int caseBlockIdx = node.getCaseBlockIndex();
+        Label defaultCase = new Label();
+        IRNode defaultBlock = null;
+        SortedMap<Integer, Pair<Label, IRNode>> cases = new TreeMap<>();
+        for (int i = 0; i < caseBlockIdx - 1; ++i) {
+            if (node.getChild(i + 1) instanceof Nothing) {
+                defaultBlock = node.getChild(i + caseBlockIdx);
+            } else {
+                Literal literal = (Literal) node.getChild(i + 1);
+                int value = 0;
+                if (literal.value instanceof Integer) {
+                    value = (Integer) literal.value;
+                } else if (literal.value instanceof Short) {
+                    value = (Short) literal.value;
+                } else if (literal.value instanceof Byte) {
+                    value = (Byte) literal.value;
+                } else if (literal.value instanceof Character) {
+                    value = (Character) literal.value;
+                }
+                cases.put(value, new Pair<>(new Label(), node.getChild(i + caseBlockIdx)));
+            }
+        }
+        Label breakLabel = new Label();
+        endLabels.push(breakLabel);
+        currentMV.visitLookupSwitchInsn(defaultCase,
+                cases.keySet().stream()
+                        .mapToInt(Integer::intValue)
+                        .toArray(),
+                cases.values().stream()
+                        .map(p -> p.first)
+                        .toArray(Label[]::new));
+        for (Pair<Label, IRNode> p : cases.values()) {
+            currentMV.visitLabel(p.first);
+            p.second.accept(this);
+        }
+        currentMV.visitLabel(defaultCase);
+        if (defaultBlock != null) {
+            defaultBlock.accept(this);
+        }
+        Label a = endLabels.pop();
+        assert breakLabel == a;
+        currentMV.visitLabel(breakLabel);
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(TernaryOperator node) {
+        IRNode conditionBlock = node.getChild(TernaryOperator.TernaryPart.CONDITION.ordinal());
+        // get the condition type to emit correct if
+        conditionBlock.accept(this);
+        generateIf(Opcodes.IFEQ, node.getChild(TernaryOperator.TernaryPart.TRUE.ordinal()),
+                node.getChild(TernaryOperator.TernaryPart.FALSE.ordinal()));
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(Throw node) {
+        node.getThowable().accept(this);
+        currentMV.visitInsn(Opcodes.ATHROW);
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(TryCatchBlock node) {
+        List<? extends IRNode> children = node.getChildren();
+        IRNode tryBlock = children.get(0);
+        IRNode finallyBlock = children.get(1);
+        Label tryStart = new Label();
+        Label tryEnd = new Label();
+        Label finallyStart = new Label();
+        Label finallyEnd = new Label();
+
+        currentMV.visitLabel(tryStart);
+        tryBlock.accept(this);
+        currentMV.visitLabel(tryEnd);
+        finallyBlock.accept(this);
+        currentMV.visitJumpInsn(Opcodes.GOTO, finallyEnd);
+        VariableInfo exInfo = new VariableInfo("ex", currentClass,
+                new TypeKlass("java.lang.Throwable"), VariableInfo.LOCAL);
+        int index = locals.addLocal(exInfo);
+        for (int i = 2; i < children.size(); ++i) {
+            Label handlerBegin = new Label();
+            Label handlerEnd = new Label();
+            CatchBlock catchBlock = (CatchBlock) children.get(i);
+            for (Type t : catchBlock.throwables) {
+                currentMV.visitTryCatchBlock(tryStart, tryEnd, handlerBegin, asInternalName(t.getName()));
+            }
+            currentMV.visitLabel(handlerBegin);
+            catchBlock.accept(this);
+            currentMV.visitLabel(handlerEnd);
+            finallyBlock.accept(this);
+            currentMV.visitJumpInsn(Opcodes.GOTO, finallyEnd);
+            currentMV.visitTryCatchBlock(handlerBegin, handlerEnd, finallyStart, null);
+        }
+
+        currentMV.visitTryCatchBlock(tryStart, tryEnd, finallyStart, null);
+        currentMV.visitLabel(finallyStart);
+        currentMV.visitVarInsn(Opcodes.ASTORE, index);
+        finallyBlock.accept(this);
+        currentMV.visitVarInsn(Opcodes.ALOAD, index);
+        currentMV.visitInsn(Opcodes.ATHROW);
+        currentMV.visitLabel(finallyEnd);
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(Type node) {
+        String name;
+        if (TypeList.isBuiltIn(node)) {
+            switch (node.getName()) {
+                case "void":
+                    name = "V";
+                    break;
+                case "boolean":
+                    name = "Z";
+                    break;
+                case "byte":
+                    name = "B";
+                    break;
+                case "char":
+                    name = "C";
+                    break;
+                case "short":
+                    name = "S";
+                    break;
+                case "int":
+                    name = "I";
+                    break;
+                case "long":
+                    name = "J";
+                    break;
+                case "float":
+                    name = "F";
+                    break;
+                case "double":
+                    name = "D";
+                    break;
+                default:
+                    throw new IllegalArgumentException("Unknown type '" + node.getName());
+            }
+        } else {
+            name = "L" + asInternalName(node.getName()) + ";";
+        }
+        return name.getBytes();
+    }
+
+    @Override
+    public byte[] visit(TypeArray node) {
+        String name;
+        String prefix = Stream.generate(() -> "[")
+                .limit(node.dimensions)
+                .collect(Collectors.joining());
+        name = prefix + new String(node.getType().accept(this));
+        return name.getBytes();
+    }
+
+    @Override
+    public byte[] visit(UnaryOperator node) {
+        OperatorKind opKind = node.getOperationKind();
+        IRNode exp = node.getChild(0);
+        // argument expression is handled separately for inc and dec operators
+        if (opKind != OperatorKind.POST_DEC && opKind != OperatorKind.POST_INC
+                && opKind != OperatorKind.PRE_DEC && opKind != OperatorKind.PRE_INC) {
+            exp.accept(this);
+        }
+        Type resultType = exp.getResultType();
+        switch (opKind) {
+            case NOT:
+                Label retTrueForNot = new Label();
+                Label endForNot = new Label();
+                currentMV.visitJumpInsn(Opcodes.IFEQ, retTrueForNot);
+                currentMV.visitInsn(Opcodes.ICONST_0);
+                currentMV.visitJumpInsn(Opcodes.GOTO, endForNot);
+                currentMV.visitLabel(retTrueForNot);
+                currentMV.visitInsn(Opcodes.ICONST_1);
+                currentMV.visitLabel(endForNot);
+                break;
+            case BIT_NOT:
+                if (resultType.equals(TypeList.LONG)) {
+                    currentMV.visitLdcInsn(-1L);
+                    currentMV.visitInsn(Opcodes.LXOR);
+                } else {
+                    currentMV.visitInsn(Opcodes.ICONST_M1);
+                    currentMV.visitInsn(Opcodes.IXOR);
+                }
+                break;
+            case UNARY_MINUS:
+                if (resultType.equals(TypeList.LONG)) {
+                    currentMV.visitInsn(Opcodes.LNEG);
+                } else if (resultType.equals(TypeList.FLOAT)) {
+                    currentMV.visitInsn(Opcodes.FNEG);
+                } else if (resultType.equals(TypeList.DOUBLE)) {
+                    currentMV.visitInsn(Opcodes.DNEG);
+                } else {
+                    currentMV.visitInsn(Opcodes.INEG);
+                }
+                break;
+            case UNARY_PLUS:
+                break;
+            case PRE_DEC:
+                lowerIncDecUnaryOperator(OperatorKind.SUB, true, node);
+                break;
+            case POST_DEC:
+                lowerIncDecUnaryOperator(OperatorKind.SUB, false, node);
+                break;
+            case PRE_INC:
+                lowerIncDecUnaryOperator(OperatorKind.ADD, true, node);
+                break;
+            case POST_INC:
+                lowerIncDecUnaryOperator(OperatorKind.ADD, false, node);
+                break;
+            default:
+                throw new RuntimeException("Incorrect unary operator: " + opKind);
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    private void lowerIncDecUnaryOperator(OperatorKind kind, boolean isPrefix, IRNode node) {
+        IRNode var = node.getChild(0);
+        Literal one;
+        Type resultType = node.getResultType();
+        if (resultType.equals(TypeList.LONG)) {
+            one = new Literal(1L, TypeList.LONG);
+        } else if (resultType.equals(TypeList.INT)) {
+            one = new Literal(1, TypeList.INT);
+        } else if (resultType.equals(TypeList.SHORT)) {
+            one = new Literal((short) 1, TypeList.SHORT);
+        } else {
+            one = new Literal((byte) 1, TypeList.BYTE);
+        }
+        if (var instanceof NonStaticMemberVariable) {
+            IRNode holder = var.getChild(0);
+            Type type = holder.getResultType();
+            VariableInfo tmpInfo = new VariableInfo("tmpObject_" + tmpObject++,
+                    currentClass, type, VariableInfo.LOCAL);
+            new Statement(new VariableInitialization(tmpInfo, holder), true).accept(this);
+            var = new NonStaticMemberVariable(new LocalVariable(tmpInfo),
+                    ((NonStaticMemberVariable) var).getVariableInfo());
+        }
+        BinaryOperator calculation = new BinaryOperator(kind, resultType, var, one);
+        BinaryOperator changeValue = new BinaryOperator(OperatorKind.ASSIGN, resultType, var, calculation);
+        Statement finalChangeStatement = new Statement(changeValue, true);
+        if (isPrefix) {
+            finalChangeStatement.accept(this);
+            var.accept(this);
+        } else {
+            var.accept(this);
+            finalChangeStatement.accept(this);
+        }
+    }
+
+    @Override
+    public byte[] visit(VariableDeclaration node) {
+        VariableInfo vi = node.getVariableInfo();
+        String ownerName = vi.getOwner().getName();
+        ContextDependedClassWriter cw = classWriters.get(ownerName);
+        String typeName = new String(vi.type.accept(this));
+        if (vi.isLocal()) {
+            locals.addLocal(vi);
+        } else {
+            FieldVisitor fv = cw.visitField(asAccessFlags(vi),
+                    vi.name,
+                    typeName,
+                    null /* Generic */,
+                    null /* Constant value */);
+            fv.visitEnd(); // doesn't need visitAnnotation and visitAttribute
+        }
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    @Override
+    public byte[] visit(VariableDeclarationBlock node) {
+        return iterateBlock(node);
+    }
+
+    @Override
+    public byte[] visit(While node) {
+        Loop loop = node.getLoop();
+        loop.initialization.accept(this);
+        node.getChild(While.WhilePart.HEADER.ordinal()).accept(this);
+        Label currentLoopBegin = new Label();
+        beginLabels.push(currentLoopBegin);
+        currentMV.visitLabel(currentLoopBegin);
+        loop.condition.accept(this);
+        assert loop.condition.getResultType() == TypeList.BOOLEAN;
+        Label currentLoopEnd = new Label();
+        endLabels.push(currentLoopEnd);
+        currentMV.visitJumpInsn(Opcodes.IFEQ, currentLoopEnd);
+        node.getChild(While.WhilePart.BODY1.ordinal()).accept(this);
+        loop.manipulator.accept(this);
+        node.getChild(While.WhilePart.BODY2.ordinal()).accept(this);
+        node.getChild(While.WhilePart.BODY3.ordinal()).accept(this);
+        currentMV.visitJumpInsn(Opcodes.GOTO, currentLoopBegin);
+        currentMV.visitLabel(currentLoopEnd);
+        Label a = beginLabels.pop();
+        assert currentLoopBegin == a;
+        a = endLabels.pop();
+        assert currentLoopEnd == a;
+        return EMPTY_BYTE_ARRAY;
+    }
+
+    public byte[] getByteCode(String name) {
+        return context.get(name);
+    }
+
+    private static byte[] concat(byte[] a, byte[] b) {
+        byte[] r = new byte[a.length + b.length];
+        System.arraycopy(a, 0, r, 0, a.length);
+        System.arraycopy(b, 0, r, a.length, b.length);
+        return r;
+    }
+
+    private String argTypeToString(ArgumentDeclaration declarations) {
+        return new String(declarations.variableInfo.type.accept(this));
+    }
+
+    private byte[] iterateBlock(IRNode node) {
+        return node.getChildren().stream()
+                .map(ch -> ch.accept(this))
+                .reduce(new byte[0], ByteCodeVisitor::concat);
+    }
+
+    private String getDescriptor(IRNode node, int skipChilds, String returnType) {
+        return node.getChildren().stream()
+                .skip(skipChilds)
+                .map(c -> argTypeToString((ArgumentDeclaration)c))
+                .collect(Collectors.joining("", "(", ")" + returnType));
+    }
+
+    private static String asInternalName(String type) {
+        return type.replace('.', '/');
+    }
+
+    private static int asAccessFlags(TypeKlass klass) {
+        int attr = Opcodes.ACC_SUPER;
+        attr |= klass.isFinal() ? Opcodes.ACC_FINAL : 0;
+        attr |= klass.isAbstract() ? Opcodes.ACC_ABSTRACT : 0;
+        attr |= klass.isInterface() ? Opcodes.ACC_INTERFACE : 0;
+
+        return attr;
+    }
+
+    private static int asAccessFlags(FunctionInfo fi) {
+        int result = asAccessFlags((Symbol) fi);
+        result |= ProductionParams.enableStrictFP.value() ? Opcodes.ACC_STRICT : 0;
+        result |= fi.isSynchronized() ? Opcodes.ACC_SYNCHRONIZED : 0;
+        return result;
+    }
+
+    private static int asAccessFlags(Symbol s) {
+        int attr = 0;
+        attr |= s.isPublic() ? Opcodes.ACC_PUBLIC : 0;
+        attr |= s.isPrivate() ? Opcodes.ACC_PRIVATE : 0;
+        attr |= s.isProtected() ? Opcodes.ACC_PROTECTED : 0;
+        attr |= s.isStatic() ? Opcodes.ACC_STATIC : 0;
+        attr |= s.isFinal() ? Opcodes.ACC_FINAL : 0;
+
+        return attr;
+    }
+
+    private static class LocalVariablesTable {
+        private int nextLocalIndex = 0;
+        // a map keeping local variable table index for a local variable
+        private final HashMap<String, Integer> locals = new HashMap<>();
+
+        public int addLocal(VariableInfo vi) {
+            int indexToReturn = nextLocalIndex;
+            locals.put(vi.name, nextLocalIndex++);
+            if (vi.type.equals(TypeList.DOUBLE) || vi.type.equals(TypeList.LONG)) {
+                nextLocalIndex++;
+            }
+            return indexToReturn;
+        }
+
+        public int getLocalIndex(VariableInfo vi) {
+            if (!locals.containsKey(vi.name)) {
+                throw new NoSuchElementException(vi.name);
+            }
+            return locals.get(vi.name);
+        }
+
+        public void clear() {
+            locals.clear();
+            nextLocalIndex = 0;
+        }
+
+        public void initFunctionArguments(FunctionInfo info) {
+            initArguments(null, info);
+        }
+
+        public void initConstructorArguments(TypeKlass owner, FunctionInfo info) {
+            Objects.requireNonNull(owner, "owner is null");
+            initArguments(owner, info);
+        }
+
+        private void initArguments(TypeKlass owner, FunctionInfo info) {
+            clear();
+            if (owner != null) {
+                addLocal(new VariableInfo("this", owner, owner, VariableInfo.LOCAL | VariableInfo.INITIALIZED));
+            }
+            for (VariableInfo vi : info.argTypes) {
+                addLocal(vi);
+            }
+        }
+    }
+
+    private static class GeneratedClassesContext extends java.lang.ClassLoader {
+        private final HashMap<String, byte[]> byteCodes = new HashMap<>();
+
+        public void register(String name, byte[] bytecode) {
+            defineClass(name, bytecode, 0, bytecode.length);
+            byteCodes.put(name, bytecode);
+        }
+
+        public byte[] get(String name) {
+            return byteCodes.get(name);
+        }
+    }
+
+
+    private static class ContextDependedClassWriter extends ClassWriter {
+        private final GeneratedClassesContext context;
+
+        public ContextDependedClassWriter(GeneratedClassesContext context, int flags) {
+            super(flags);
+            this.context = context;
+        }
+
+        protected String getCommonSuperClass(String className1, String className2) {
+            Class<?> klass1;
+            Class<?> klass2;
+            try {
+                klass1 = Class.forName(className1.replace('/', '.'), false, context);
+                klass2 = Class.forName(className2.replace('/', '.'), false, context);
+            } catch (ClassNotFoundException e) {
+                throw new Error("can not get common supper for " + className1
+                                + " and " + className2, e);
+            }
+
+            if (klass1.isAssignableFrom(klass2)) {
+                return className1;
+            } else if (klass2.isAssignableFrom(klass1)) {
+                return className2;
+            } else if (!klass1.isInterface() && !klass2.isInterface()) {
+                do {
+                    klass1 = klass1.getSuperclass();
+                } while (!klass1.isAssignableFrom(klass2));
+
+                return asInternalName(className1);
+            } else {
+                return "java/lang/Object";
+            }
+        }
+    }
+}