system .|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|.
{
    active main thread MAIN()
    {
        transient (|java.lang.Thread|) th;
        transient VM.F f$;

        loc l0: live { th, f$ }
            do independent
            {
                th := new (|java.lang.Thread|);
                VM.nwF(f$, 0);
                VM.max(f$, 1, 1);
                VM.psh<(|java.lang.Thread|)>(f$, th);
                VM.lcl(f$, Op.ASTORE, 0);
            }
            goto l1;
        loc l1: live { th }
            independent invoke {|java.lang.Thread.()V|}(th, f$) goto l2;
        loc l2: live { th, f$ }
            do independent
            {
                VM.nwF(f$, 0);
            }
            goto l3;
        loc l3: live { th }
            independent invoke {|java.lang.Object.()V|}(f$) goto l4;
        loc l4: live { th, f$ }
            do independent
            {
                VM.nwF(f$, 0);
            }
            goto l5;
        loc l5: live { th }
            independent invoke {|java.lang.Thread.()V|}(f$) goto l6;
        loc l6: live { th, f$ }
            do independent
            {
                VM.nwF(f$, 0);
            }
            goto l7;
        loc l7: live { th }
            independent invoke {|java.lang.String.()V|}(f$) goto l8;
        loc l8: live { th, f$ }
            do independent
            {
                VM.nwF(f$, 0);
            }
            goto l9;
        loc l9: live { th }
            independent invoke {|java.lang.Class.()V|}(f$) goto l10;
        loc l10: live { th, f$ }
            do independent
            {
                VM.nwF(f$, 0);
            }
            goto l11;
        loc l11: live { th }
            independent invoke {|java.lang.Thread$State.()V|}(f$) goto l12;
        loc l12: live { th, f$ }
            do independent
            {
                VM.nwF(f$, 0);
            }
            goto l13;
        loc l13: live { th }
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.main([Ljava/lang/String;)V|}(f$) return;
    }
    record (|java.lang.InterruptedException|) extends (|java.lang.Exception|) {}
    record (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|) extends (|java.lang.Thread|) { (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) /|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1.in|\;(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) /|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1.out|\; }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1.(Ledu/ksu/cis/projects/bogor/vm/translator/test/boundedbuffer/b1/BoundedBuffer;Ledu/ksu/cis/projects/bogor/vm/translator/test/boundedbuffer/b1/BoundedBuffer;)V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|) this, VM.F f)
    {
        VM.F f$;

        loc l0$49:
            do independent
            {
                VM.max(f, 3, 2);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|)>(f, "this", 0);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "ins", 1);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "outs", 2);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l2$49;
        loc $l2$49:
            independent invoke {|java.lang.Thread.()V|}(VM.getL<(|java.lang.Thread|)>(f$, 0), f$) goto l3$50;
        loc l3$50:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l4;
        loc l4:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l5$50;
        loc l5$50:
            do
            {
                VM.fld(f, Op.PUTFIELD, "in");
            }
            goto l6$51;
        loc l6$51:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l7;
        loc l7:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l8$51;
        loc l8$51:
            do
            {
                VM.fld(f, Op.PUTFIELD, "out");
            }
            goto l9$52;
        loc l9$52:
            do independent
            {
            }
            return;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1.run()V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|) this, VM.F f)
    {
        (|java.lang.Object|) t$0;
        VM.F f$;

        loc l0$56:
            do independent
            {
                VM.max(f, 2, 2);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|)>(f, "this", 0);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do
            {
                VM.fld(f, Op.GETFIELD, "in");
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l3;
        loc $l3:
            t$0 := independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.take()Ljava/lang/Object;|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto $l4;
        loc $l4:
            do independent
            {
                VM.psh<(|java.lang.Object|)>(f, t$0);
            }
            goto l5$56;
        loc l5$56:
            do independent
            {
                VM.set<(|java.lang.Object|)>(f, "tmp", 1);
                VM.lcl(f, Op.ASTORE, 1);
            }
            goto l6$57;
        loc l6$57:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l7;
        loc l7:
            do
            {
                VM.fld(f, Op.GETFIELD, "out");
            }
            goto l8;
        loc l8:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l9;
        loc l9:
            do independent
            {
                VM.nwF(f$, 2, f);
            }
            goto $l10$57;
        loc $l10$57:
            independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.add(Ljava/lang/Object;)V|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto l11$55;
        loc l11$55:
            do independent
            {
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|)>(f, "this", 0);
                VM.unset(f, 1);
            }
            goto l0$56;
    }
    record (|java.lang.Comparable|) extends (|java.lang.Object|) {}
    record (|java.lang.Exception|) extends (|java.lang.Throwable|) {}
    record (|java.lang.Runnable|) extends (|java.lang.Object|) {}
    record (|java.lang.Thread$UncaughtExceptionHandler|) extends (|java.lang.Object|) {}
    record (|java.lang.reflect.Type|) extends (|java.lang.Object|) {}
    record (|java.lang.reflect.AnnotatedElement|) extends (|java.lang.Object|) {}
    record (|java.lang.CharSequence|) extends (|java.lang.Object|) {}
    record (|java.io.Serializable|) extends (|java.lang.Object|) {}
    record (|java.lang.reflect.GenericDeclaration|) extends (|java.lang.Object|) {}
    record (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) extends (|java.lang.Object|) { (|java.lang.Object|)[] /|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.buffer|\;int /|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.bound|\;int /|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.head|\;int /|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.tail|\; }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.main([Ljava/lang/String;)V|}(VM.F f)
    {
        VM.F f$;

        loc l0$8:
            do independent
            {
                VM.max(f, 3, 4);
                VM.set<(|java.lang.String|)[]>(f, "args", 0);
                VM.typ<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, Op.NEW);
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.zro(f, Op.ICONST_3);
            }
            goto l3;
        loc l3:
            do independent
            {
                VM.nwF(f$, 2, f);
            }
            goto $l4;
        loc $l4:
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.(I)V|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto l5$8;
        loc l5$8:
            do independent
            {
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "b1", 1);
                VM.lcl(f, Op.ASTORE, 1);
            }
            goto l6$9;
        loc l6$9:
            do independent
            {
                VM.typ<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, Op.NEW);
            }
            goto l7;
        loc l7:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l8;
        loc l8:
            do independent
            {
                VM.zro(f, Op.ICONST_3);
            }
            goto l9;
        loc l9:
            do independent
            {
                VM.nwF(f$, 2, f);
            }
            goto $l10;
        loc $l10:
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.(I)V|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto l11$9;
        loc l11$9:
            do independent
            {
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "b2", 2);
                VM.lcl(f, Op.ASTORE, 2);
            }
            goto l12$11;
        loc l12$11:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l13;
        loc l13:
            do independent
            {
                VM.typ<(|java.lang.Object|)>(f, Op.NEW);
            }
            goto l14;
        loc l14:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l15;
        loc l15:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l16;
        loc $l16:
            independent invoke {|java.lang.Object.()V|}(VM.getL<(|java.lang.Object|)>(f$, 0), f$) goto l17;
        loc l17:
            do independent
            {
                VM.nwF(f$, 2, f);
            }
            goto $l18$11;
        loc $l18$11:
            independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.add(Ljava/lang/Object;)V|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto l19$12;
        loc l19$12:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l20;
        loc l20:
            do independent
            {
                VM.typ<(|java.lang.Object|)>(f, Op.NEW);
            }
            goto l21;
        loc l21:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l22;
        loc l22:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l23;
        loc $l23:
            independent invoke {|java.lang.Object.()V|}(VM.getL<(|java.lang.Object|)>(f$, 0), f$) goto l24;
        loc l24:
            do independent
            {
                VM.nwF(f$, 2, f);
            }
            goto $l25$12;
        loc $l25$12:
            independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.add(Ljava/lang/Object;)V|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto l26$14;
        loc l26$14:
            do independent
            {
                VM.typ<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|)>(f, Op.NEW);
            }
            goto l27;
        loc l27:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l28;
        loc l28:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l29;
        loc l29:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l30;
        loc l30:
            do independent
            {
                VM.nwF(f$, 3, f);
            }
            goto $l31;
        loc $l31:
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1.(Ledu/ksu/cis/projects/bogor/vm/translator/test/boundedbuffer/b1/BoundedBuffer;Ledu/ksu/cis/projects/bogor/vm/translator/test/boundedbuffer/b1/BoundedBuffer;)V|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|)>(f$, 0), f$) goto l32;
        loc l32:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l33$14;
        loc $l33$14:
            independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1.start()V|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|)>(f$, 0), f$) goto l34$15;
        loc l34$15:
            do independent
            {
                VM.typ<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|)>(f, Op.NEW);
            }
            goto l35;
        loc l35:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l36;
        loc l36:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l37;
        loc l37:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l38;
        loc l38:
            do independent
            {
                VM.nwF(f$, 3, f);
            }
            goto $l39;
        loc $l39:
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2.(Ledu/ksu/cis/projects/bogor/vm/translator/test/boundedbuffer/b1/BoundedBuffer;Ledu/ksu/cis/projects/bogor/vm/translator/test/boundedbuffer/b1/BoundedBuffer;)V|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|)>(f$, 0), f$) goto l40;
        loc l40:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l41$15;
        loc $l41$15:
            independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2.start()V|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|)>(f$, 0), f$) goto l42$16;
        loc l42$16:
            do independent
            {
            }
            return;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.(I)V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) this, VM.F f)
    {
        VM.F f$;

        loc l0$18:
            do independent
            {
                VM.max(f, 2, 3);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "this", 0);
                VM.set(f, "b", 1);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l2$18;
        loc $l2$18:
            independent invoke {|java.lang.Object.()V|}(VM.getL<(|java.lang.Object|)>(f$, 0), f$) goto l3$19;
        loc l3$19:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l4;
        loc l4:
            do independent
            {
                VM.lcl(f, Op.ILOAD, 1);
            }
            goto l5$19;
        loc l5$19:
            do
            {
                VM.fld(f, Op.PUTFIELD, "bound");
            }
            goto l6$20;
        loc l6$20:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l7;
        loc l7:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l8;
        loc l8:
            do
            {
                VM.fld(f, Op.GETFIELD, "bound");
            }
            goto l9;
        loc l9:
            do independent
            {
                VM.typ<(|java.lang.Object|)>(f, Op.ANEWARRAY);
            }
            goto l10$20;
        loc l10$20:
            do
            {
                VM.fld(f, Op.PUTFIELD, "buffer");
            }
            goto l11$21;
        loc l11$21:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l12;
        loc l12:
            do independent
            {
                VM.zro(f, Op.ICONST_0);
            }
            goto l13$21;
        loc l13$21:
            do
            {
                VM.fld(f, Op.PUTFIELD, "head");
            }
            goto l14$22;
        loc l14$22:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l15;
        loc l15:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l16;
        loc l16:
            do
            {
                VM.fld(f, Op.GETFIELD, "bound");
            }
            goto l17;
        loc l17:
            do independent
            {
                VM.zro(f, Op.ICONST_1);
            }
            goto l18;
        loc l18:
            do independent
            {
                VM.zro(f, Op.ISUB);
            }
            goto l19$22;
        loc l19$22:
            do
            {
                VM.fld(f, Op.PUTFIELD, "tail");
            }
            goto l20$23;
        loc l20$23:
            do independent
            {
            }
            return;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.add(Ljava/lang/Object;)V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) this, VM.F f)
    {
        (|java.lang.Throwable|) t;
        VM.F f$;
        (|java.lang.Object|) o;
        (|java.lang.Thread|) th;

        loc l0:
            do independent
            {
                VM.max(f, 3, 4);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "this", 0);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.lcl(f, Op.ASTORE, 2);
            }
            goto l3;
        loc l3:
            do independent
            {
                th := Thread.trd();
                assert th.state == /|java.lang.Thread$State.RUNNABLE|\;
                o := VM.tpS<(|java.lang.Object|)>(f);
            }
            goto $l4;
        loc $l4:
            when o == null || lockAvailable(o.l) do
            {
                lock(o.l);
                VM.rmv(f);
                th.state := /|java.lang.Thread$State.RUNNABLE|\;
            }
            goto l5;
            when !(o == null || lockAvailable(o.l)) && th.state != /|java.lang.Thread$State.BLOCKED|\ do independent
            {
                th.state := /|java.lang.Thread$State.BLOCKED|\;
            }
            goto $l4;
        loc l5:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l6;
        loc l6:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l7;
        loc l7:
            do independent
            {
                VM.nwF(f$, 2, f);
            }
            goto $l8;
        loc $l8:
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.!add(Ljava/lang/Object;)V|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto l9;
        loc l9:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l10;
        loc l10:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l11;
        loc l11:
            do independent
            {
            }
            return;
        loc l12:
            do independent
            {
                VM.psh<(|java.lang.Throwable|)>(f, t);
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l13;
        loc l13:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l14;
        loc l14:
            do independent
            {
                VM.pop<(|java.lang.Throwable|)>(f, t);
                throw t;
            }
            goto l14;
        catch (|java.lang.Throwable|) t at l5, l6, l7, $l8, l9, l10 goto l12;
        catch (|java.lang.Throwable|) t at l12, l13 goto l12;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.!add(Ljava/lang/Object;)V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) this, VM.F f)
    {
        boolean b;
        (|java.lang.Throwable|) t;
        VM.F f$;

        loc l0$26:
            do independent
            {
                VM.max(f, 3, 3);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "this", 0);
                VM.set<(|java.lang.Object|)>(f, "o", 1);
            }
            goto l6$26;
        loc l1$27:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l3;
        loc $l3:
            independent invoke virtual +|java.lang.Object.wait()V|+(VM.getL<(|java.lang.Object|)>(f$, 0), f$) goto l4$27;
        loc l4$27:
            do independent
            {
            }
            goto l6$26;
        loc l5$27:
            do independent
            {
                VM.psh<(|java.lang.Throwable|)>(f, t);
                VM.lcl(f, Op.ASTORE, 2);
            }
            goto l6$26;
        loc l6$26:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l7;
        loc l7:
            do
            {
                VM.fld(f, Op.GETFIELD, "tail");
            }
            goto l8;
        loc l8:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l9;
        loc l9:
            do
            {
                VM.fld(f, Op.GETFIELD, "head");
            }
            goto l10;
        loc l10:
            do independent
            {
                VM.cmp(f, Op.ICMPEQ, b);
            }
            goto $l11$26;
        loc $l11$26:
            when b do independent
            {
            }
            goto l1$27;
            when !(b) do independent
            {
            }
            goto l12$29;
        loc l12$29:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l13;
        loc l13:
            do
            {
                VM.fld(f, Op.GETFIELD, "buffer");
            }
            goto l14;
        loc l14:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l15;
        loc l15:
            do
            {
                VM.fld(f, Op.GETFIELD, "head");
            }
            goto l16;
        loc l16:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l17$29;
        loc l17$29:
            do
            {
                VM.zro(f, Op.AASTORE);
            }
            goto l18$30;
        loc l18$30:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l19;
        loc l19:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l20;
        loc l20:
            do
            {
                VM.fld(f, Op.GETFIELD, "head");
            }
            goto l21;
        loc l21:
            do independent
            {
                VM.zro(f, Op.ICONST_1);
            }
            goto l22;
        loc l22:
            do independent
            {
                VM.zro(f, Op.IADD);
            }
            goto l23;
        loc l23:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l24;
        loc l24:
            do
            {
                VM.fld(f, Op.GETFIELD, "bound");
            }
            goto l25;
        loc l25:
            do independent
            {
                VM.zro(f, Op.IREM);
            }
            goto l26$30;
        loc l26$30:
            do
            {
                VM.fld(f, Op.PUTFIELD, "head");
            }
            goto l27$31;
        loc l27$31:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l28;
        loc l28:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l29$31;
        loc $l29$31:
            independent invoke virtual +|java.lang.Object.notifyAll()V|+(VM.getL<(|java.lang.Object|)>(f$, 0), f$) goto l30$32;
        loc l30$32:
            do independent
            {
            }
            return;
        catch (|java.lang.InterruptedException|) t at l1$27, l2, $l3, l4$27 goto l5$27;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.take()Ljava/lang/Object;|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) this, VM.F f) returns (|java.lang.Object|)
    {
        (|java.lang.Object|) t$0;
        (|java.lang.Object|) r;
        (|java.lang.Throwable|) t;
        VM.F f$;
        (|java.lang.Object|) o;
        (|java.lang.Thread|) th;

        loc l0:
            do independent
            {
                VM.max(f, 2, 3);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "this", 0);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.lcl(f, Op.ASTORE, 1);
            }
            goto l3;
        loc l3:
            do independent
            {
                th := Thread.trd();
                assert th.state == /|java.lang.Thread$State.RUNNABLE|\;
                o := VM.tpS<(|java.lang.Object|)>(f);
            }
            goto $l4;
        loc $l4:
            when o == null || lockAvailable(o.l) do
            {
                lock(o.l);
                VM.rmv(f);
                th.state := /|java.lang.Thread$State.RUNNABLE|\;
            }
            goto l5;
            when !(o == null || lockAvailable(o.l)) && th.state != /|java.lang.Thread$State.BLOCKED|\ do independent
            {
                th.state := /|java.lang.Thread$State.BLOCKED|\;
            }
            goto $l4;
        loc l5:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l6;
        loc l6:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l7;
        loc $l7:
            t$0 := independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.!take()Ljava/lang/Object;|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto $l8;
        loc $l8:
            do independent
            {
                VM.psh<(|java.lang.Object|)>(f, t$0);
            }
            goto l9;
        loc l9:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l10;
        loc l10:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l11;
        loc l11:
            do independent
            {
                VM.pop<(|java.lang.Object|)>(f, r);
            }
            return r;
        loc l12:
            do independent
            {
                VM.psh<(|java.lang.Throwable|)>(f, t);
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l13;
        loc l13:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l14;
        loc l14:
            do independent
            {
                VM.pop<(|java.lang.Throwable|)>(f, t);
                throw t;
            }
            goto l14;
        catch (|java.lang.Throwable|) t at l5, l6, $l7, $l8, l9, l10 goto l12;
        catch (|java.lang.Throwable|) t at l12, l13 goto l12;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.!take()Ljava/lang/Object;|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) this, VM.F f) returns (|java.lang.Object|)
    {
        boolean t$0;
        (|java.lang.Object|) r;
        boolean b;
        (|java.lang.Throwable|) t;
        VM.F f$;

        loc l0$35:
            do independent
            {
                VM.max(f, 2, 3);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "this", 0);
            }
            goto l6$35;
        loc l1$36:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l3;
        loc $l3:
            independent invoke virtual +|java.lang.Object.wait()V|+(VM.getL<(|java.lang.Object|)>(f$, 0), f$) goto l4$36;
        loc l4$36:
            do independent
            {
            }
            goto l6$35;
        loc l5$36:
            do independent
            {
                VM.psh<(|java.lang.Throwable|)>(f, t);
                VM.lcl(f, Op.ASTORE, 1);
            }
            goto l6$35;
        loc l6$35:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l7;
        loc l7:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l8;
        loc $l8:
            t$0 := independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.isEmpty()Z|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto $l9;
        loc $l9:
            do independent
            {
                VM.psh(f, t$0);
            }
            goto l10;
        loc l10:
            do independent
            {
                VM.cmp(f, Op.NE, b);
            }
            goto $l11$35;
        loc $l11$35:
            when b do independent
            {
            }
            goto l1$36;
            when !(b) do independent
            {
            }
            goto l12$39;
        loc l12$39:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l13;
        loc l13:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l14;
        loc l14:
            do
            {
                VM.fld(f, Op.GETFIELD, "tail");
            }
            goto l15;
        loc l15:
            do independent
            {
                VM.zro(f, Op.ICONST_1);
            }
            goto l16;
        loc l16:
            do independent
            {
                VM.zro(f, Op.IADD);
            }
            goto l17;
        loc l17:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l18;
        loc l18:
            do
            {
                VM.fld(f, Op.GETFIELD, "bound");
            }
            goto l19;
        loc l19:
            do independent
            {
                VM.zro(f, Op.IREM);
            }
            goto l20$39;
        loc l20$39:
            do
            {
                VM.fld(f, Op.PUTFIELD, "tail");
            }
            goto l21$40;
        loc l21$40:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l22;
        loc l22:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l23$40;
        loc $l23$40:
            independent invoke virtual +|java.lang.Object.notifyAll()V|+(VM.getL<(|java.lang.Object|)>(f$, 0), f$) goto l24$41;
        loc l24$41:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l25;
        loc l25:
            do
            {
                VM.fld(f, Op.GETFIELD, "buffer");
            }
            goto l26;
        loc l26:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l27;
        loc l27:
            do
            {
                VM.fld(f, Op.GETFIELD, "tail");
            }
            goto l28;
        loc l28:
            do
            {
                VM.zro(f, Op.AALOAD);
            }
            goto l29$41;
        loc l29$41:
            do independent
            {
                VM.pop<(|java.lang.Object|)>(f, r);
            }
            return r;
        catch (|java.lang.InterruptedException|) t at l1$36, l2, $l3, l4$36 goto l5$36;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.isEmpty()Z|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) this, VM.F f) returns boolean
    {
        boolean t$0;
        boolean r;
        (|java.lang.Throwable|) t;
        VM.F f$;
        (|java.lang.Object|) o;
        (|java.lang.Thread|) th;

        loc l0:
            do independent
            {
                VM.max(f, 2, 3);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "this", 0);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.lcl(f, Op.ASTORE, 1);
            }
            goto l3;
        loc l3:
            do independent
            {
                th := Thread.trd();
                assert th.state == /|java.lang.Thread$State.RUNNABLE|\;
                o := VM.tpS<(|java.lang.Object|)>(f);
            }
            goto $l4;
        loc $l4:
            when o == null || lockAvailable(o.l) do
            {
                lock(o.l);
                VM.rmv(f);
                th.state := /|java.lang.Thread$State.RUNNABLE|\;
            }
            goto l5;
            when !(o == null || lockAvailable(o.l)) && th.state != /|java.lang.Thread$State.BLOCKED|\ do independent
            {
                th.state := /|java.lang.Thread$State.BLOCKED|\;
            }
            goto $l4;
        loc l5:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l6;
        loc l6:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l7;
        loc $l7:
            t$0 := independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.!isEmpty()Z|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto $l8;
        loc $l8:
            do independent
            {
                VM.psh(f, t$0);
            }
            goto l9;
        loc l9:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l10;
        loc l10:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l11;
        loc l11:
            do independent
            {
                VM.pop(f, r);
            }
            return r;
        loc l12:
            do independent
            {
                VM.psh<(|java.lang.Throwable|)>(f, t);
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l13;
        loc l13:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l14;
        loc l14:
            do independent
            {
                VM.pop<(|java.lang.Throwable|)>(f, t);
                throw t;
            }
            goto l14;
        catch (|java.lang.Throwable|) t at l5, l6, $l7, $l8, l9, l10 goto l12;
        catch (|java.lang.Throwable|) t at l12, l13 goto l12;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.!isEmpty()Z|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) this, VM.F f) returns boolean
    {
        boolean r;
        boolean b;

        loc l0$44:
            do independent
            {
                VM.max(f, 1, 3);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "this", 0);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do
            {
                VM.fld(f, Op.GETFIELD, "head");
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l3;
        loc l3:
            do
            {
                VM.fld(f, Op.GETFIELD, "tail");
            }
            goto l4;
        loc l4:
            do independent
            {
                VM.zro(f, Op.ICONST_1);
            }
            goto l5;
        loc l5:
            do independent
            {
                VM.zro(f, Op.IADD);
            }
            goto l6;
        loc l6:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l7;
        loc l7:
            do
            {
                VM.fld(f, Op.GETFIELD, "bound");
            }
            goto l8;
        loc l8:
            do independent
            {
                VM.zro(f, Op.IREM);
            }
            goto l9;
        loc l9:
            do independent
            {
                VM.cmp(f, Op.ICMPNE, b);
            }
            goto $l10;
        loc $l10:
            when b do independent
            {
            }
            goto l13$44;
            when !(b) do independent
            {
            }
            goto l11;
        loc l11:
            do independent
            {
                VM.zro(f, Op.ICONST_1);
            }
            goto l12$44;
        loc l12$44:
            do independent
            {
                VM.pop(f, r);
            }
            return r;
        loc l13$44:
            do independent
            {
                VM.zro(f, Op.ICONST_0);
            }
            goto l14$44;
        loc l14$44:
            do independent
            {
                VM.pop(f, r);
            }
            return r;
    }
    record (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|) extends (|java.lang.Thread|) { (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) /|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2.in|\;(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) /|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2.out|\; }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2.(Ledu/ksu/cis/projects/bogor/vm/translator/test/boundedbuffer/b1/BoundedBuffer;Ledu/ksu/cis/projects/bogor/vm/translator/test/boundedbuffer/b1/BoundedBuffer;)V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|) this, VM.F f)
    {
        VM.F f$;

        loc l0$64:
            do independent
            {
                VM.max(f, 3, 2);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|)>(f, "this", 0);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "ins", 1);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f, "outs", 2);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l2$64;
        loc $l2$64:
            independent invoke {|java.lang.Thread.()V|}(VM.getL<(|java.lang.Thread|)>(f$, 0), f$) goto l3$65;
        loc l3$65:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l4;
        loc l4:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l5$65;
        loc l5$65:
            do
            {
                VM.fld(f, Op.PUTFIELD, "in");
            }
            goto l6$66;
        loc l6$66:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l7;
        loc l7:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l8$66;
        loc l8$66:
            do
            {
                VM.fld(f, Op.PUTFIELD, "out");
            }
            goto l9$67;
        loc l9$67:
            do independent
            {
            }
            return;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2.run()V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|) this, VM.F f)
    {
        (|java.lang.Object|) t$0;
        VM.F f$;

        loc l0$71:
            do independent
            {
                VM.max(f, 2, 2);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|)>(f, "this", 0);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do
            {
                VM.fld(f, Op.GETFIELD, "in");
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l3;
        loc $l3:
            t$0 := independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.take()Ljava/lang/Object;|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto $l4;
        loc $l4:
            do independent
            {
                VM.psh<(|java.lang.Object|)>(f, t$0);
            }
            goto l5$71;
        loc l5$71:
            do independent
            {
                VM.set<(|java.lang.Object|)>(f, "tmp", 1);
                VM.lcl(f, Op.ASTORE, 1);
            }
            goto l6$72;
        loc l6$72:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l7;
        loc l7:
            do
            {
                VM.fld(f, Op.GETFIELD, "out");
            }
            goto l8;
        loc l8:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l9;
        loc l9:
            do independent
            {
                VM.nwF(f$, 2, f);
            }
            goto $l10$72;
        loc $l10$72:
            independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.add(Ljava/lang/Object;)V|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|)>(f$, 0), f$) goto l11$70;
        loc l11$70:
            do independent
            {
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|)>(f, "this", 0);
                VM.unset(f, 1);
            }
            goto l0$71;
    }
    virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.take()Ljava/lang/Object;|+ { (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) -> {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.take()Ljava/lang/Object;|} }
    virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2.start()V|+ { (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|) -> {|java.lang.Thread.start()V|} }
    virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1.start()V|+ { (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|) -> {|java.lang.Thread.start()V|} }
    virtual +|java.lang.Object.notifyAll()V|+ { (|java.lang.Object|) -> {|java.lang.Object.notifyAll()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) -> {|java.lang.Object.notifyAll()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|) -> {|java.lang.Object.notifyAll()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|) -> {|java.lang.Object.notifyAll()V|} (|java.io.Serializable|) -> +|java.lang.Object.notifyAll()V|+ (|java.lang.CharSequence|) -> +|java.lang.Object.notifyAll()V|+ (|java.lang.Class|) -> {|java.lang.Object.notifyAll()V|} (|java.lang.Comparable|) -> +|java.lang.Object.notifyAll()V|+ (|java.lang.Enum|) -> {|java.lang.Object.notifyAll()V|} (|java.lang.Exception|) -> {|java.lang.Object.notifyAll()V|} (|java.lang.InterruptedException|) -> {|java.lang.Object.notifyAll()V|} (|java.lang.Runnable|) -> +|java.lang.Object.notifyAll()V|+ (|java.lang.String|) -> {|java.lang.Object.notifyAll()V|} (|java.lang.Thread|) -> {|java.lang.Object.notifyAll()V|} (|java.lang.Thread$State|) -> {|java.lang.Object.notifyAll()V|} (|java.lang.Thread$UncaughtExceptionHandler|) -> +|java.lang.Object.notifyAll()V|+ (|java.lang.Throwable|) -> {|java.lang.Object.notifyAll()V|} (|java.lang.reflect.AnnotatedElement|) -> +|java.lang.Object.notifyAll()V|+ (|java.lang.reflect.GenericDeclaration|) -> +|java.lang.Object.notifyAll()V|+ (|java.lang.reflect.Type|) -> +|java.lang.Object.notifyAll()V|+ }
    virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.add(Ljava/lang/Object;)V|+ { (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) -> {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.add(Ljava/lang/Object;)V|} }
    virtual +|java.lang.Thread.run()V|+ { (|java.lang.Thread|) -> {|java.lang.Thread.run()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|) -> {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1.run()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|) -> {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2.run()V|} }
    virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.isEmpty()Z|+ { (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) -> {|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer.isEmpty()Z|} }
    virtual +|java.lang.Object.wait()V|+ { (|java.lang.Object|) -> {|java.lang.Object.wait()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.BoundedBuffer|) -> {|java.lang.Object.wait()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut1|) -> {|java.lang.Object.wait()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.boundedbuffer.b1.InOut2|) -> {|java.lang.Object.wait()V|} (|java.io.Serializable|) -> +|java.lang.Object.wait()V|+ (|java.lang.CharSequence|) -> +|java.lang.Object.wait()V|+ (|java.lang.Class|) -> {|java.lang.Object.wait()V|} (|java.lang.Comparable|) -> +|java.lang.Object.wait()V|+ (|java.lang.Enum|) -> {|java.lang.Object.wait()V|} (|java.lang.Exception|) -> {|java.lang.Object.wait()V|} (|java.lang.InterruptedException|) -> {|java.lang.Object.wait()V|} (|java.lang.Runnable|) -> +|java.lang.Object.wait()V|+ (|java.lang.String|) -> {|java.lang.Object.wait()V|} (|java.lang.Thread|) -> {|java.lang.Object.wait()V|} (|java.lang.Thread$State|) -> {|java.lang.Object.wait()V|} (|java.lang.Thread$UncaughtExceptionHandler|) -> +|java.lang.Object.wait()V|+ (|java.lang.Throwable|) -> {|java.lang.Object.wait()V|} (|java.lang.reflect.AnnotatedElement|) -> +|java.lang.Object.wait()V|+ (|java.lang.reflect.GenericDeclaration|) -> +|java.lang.Object.wait()V|+ (|java.lang.reflect.Type|) -> +|java.lang.Object.wait()V|+ }
    extension Class for edu.ksu.cis.projects.bogor.vm.lib.java.lang.ClassModule
    {
        expdef (|java.lang.Class|) cls (string name);
        expdef (|java.lang.Class|) tCls <'a>();
        expdef (|java.lang.String|) toS (string...);
    }
    function {|java.lang.Class.()V|}(VM.F f)
    {

        loc l0:
            do independent
            {
            }
            return;
    }
    record (|java.lang.Class|) extends (|java.lang.Object|), (|java.io.Serializable|), (|java.lang.reflect.GenericDeclaration|), (|java.lang.reflect.Type|), (|java.lang.reflect.AnnotatedElement|) { string name; }
    record (|java.lang.Enum|) extends (|java.lang.Object|) {}
    extension Object for edu.ksu.cis.projects.bogor.vm.lib.java.lang.ObjectModule
    {
        expdef string tos ((|java.lang.Object|) o);
        expdef int hsh ((|java.lang.Object|) o);
        expdef string typeName ((|java.lang.Object|) o);
    }
    top record (|java.lang.Object|) { lock l; }
    function {|java.lang.Object.()V|}(VM.F f)
    {

        loc l0:
            do independent
            {
            }
            return;
    }
    function {|java.lang.Object.()V|}(transient (|java.lang.Object|) this, VM.F f)
    {

        loc l0:
            do independent
            {
            }
            return;
    }
    function {|java.lang.Object.notifyAll()V|}(transient (|java.lang.Object|) this, VM.F f)
    {

        loc l0:
            do independent
            {
                notifyAll(this.l);
            }
            return;
    }
    function {|java.lang.Object.wait()V|}(transient (|java.lang.Object|) this, VM.F f)
    {

        loc l0:
            do independent
            {
                wait(this.l);
                (Thread.trd()).state := /|java.lang.Thread$State.WAITING|\;
            }
            goto l1;
        loc l1:
            when lockAvailable(this.l) && wasNotified(this.l) do independent
            {
                unwait(this.l);
                (Thread.trd()).state := /|java.lang.Thread$State.RUNNABLE|\;
            }
            return;
    }
    extension String for edu.ksu.cis.projects.bogor.vm.lib.java.lang.StringModule
    {
        expdef (|java.lang.String|) toS (string s, boolean internalize);
        expdef (|java.lang.String|)[] toSs (string[] ss, boolean internalize);
        expdef (|java.lang.String|) intern ((|java.lang.String|) s);
        expdef string tos ((|java.lang.String|) s);
        expdef boolean equals (string s1, string s2);
        expdef string append (string...);
    }
    record (|java.lang.String|) extends (|java.lang.Object|), (|java.io.Serializable|), (|java.lang.Comparable|), (|java.lang.CharSequence|) { Reflect.type<(|java.lang.String|)>  internal; }
    function {|java.lang.String.()V|}(VM.F f)
    {

        loc l0:
            do independent
            {
            }
            return;
    }
    extension Thread for edu.ksu.cis.projects.bogor.vm.lib.java.lang.ThreadModule
    {
        expdef tid gTID ();
        expdef boolean own (lock l);
        expdef (|java.lang.Thread|) trd ();
        expdef string itos (int i);
        expdef (|java.lang.String|) toS (string...);
    }
    transient int /|java.lang.Thread.MIN_PRIORITY|\;
    transient int /|java.lang.Thread.NORM_PRIORITY|\;
    transient int /|java.lang.Thread.MAX_PRIORITY|\;
    (|java.lang.Thread$UncaughtExceptionHandler|) tueh;
    function {|java.lang.Thread.()V|}(VM.F f)
    {

        loc l0:
            do independent
            {
                /|java.lang.Thread.MIN_PRIORITY|\ := 10;
                /|java.lang.Thread.NORM_PRIORITY|\ := 1;
                /|java.lang.Thread.MAX_PRIORITY|\ := 5;
            }
            return;
    }
    record (|java.lang.Thread|) extends (|java.lang.Object|), (|java.lang.Runnable|) { (|java.lang.Thread$State|) state;int priority;(|java.lang.Runnable|) target;boolean interrupted;(|java.lang.Thread$UncaughtExceptionHandler|) tueh; }
    function {|java.lang.Thread.()V|}(transient (|java.lang.Thread|) this, VM.F f)
    {
        VM.F f$;

        loc l0:
            do independent
            {
                VM.max(f, 1, 1);
                VM.lcl(f, Op.ALOAD, 0);
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto l2;
        loc l2:
            independent invoke {|java.lang.Object.()V|}(this, f$) goto l3;
        loc l3:
            do independent
            {
                this.state := /|java.lang.Thread$State.NEW|\;
                this.priority := /|java.lang.Thread.NORM_PRIORITY|\;
            }
            return;
    }
    function {|java.lang.Thread.start()V|}(transient (|java.lang.Thread|) this, VM.F f)
    {

        loc l0:
            do independent
            {
                this.state := /|java.lang.Thread$State.RUNNABLE|\;
                start +|java.lang.Thread|+ (this, f);
            }
            return;
    }
    thread +|java.lang.Thread|+(transient (|java.lang.Thread|) this, VM.F f)
    {
        transient (|java.lang.Throwable|) t;

        loc l0:
            do independent
            {
                VM.max(f, 1, 0);
                VM.set<(|java.lang.Thread|)>(f, "this", 0);
            }
            goto l1;
        loc l1:
            independent invoke virtual +|java.lang.Thread.run()V|+(this, f) goto l2;
        loc l2:
            do independent
            {
                this.state := /|java.lang.Thread$State.TERMINATED|\;
            }
            return;
        loc l3:
            do independent
            {
                this.state := /|java.lang.Thread$State.TERMINATED|\;
            }
            goto l4;
        loc l4:
            when this.tueh == null && tueh == null do independent
            {
                throw t;
            }
            goto l4;
        catch (|java.lang.Throwable|) t at l1 goto l3;
    }
    function {|java.lang.Thread.run()V|}(transient (|java.lang.Thread|) this, VM.F f)
    {

        loc l0:
            do independent
            {
            }
            return;
    }
    record (|java.lang.Thread$State|) extends (|java.lang.Enum|) { string name; }
    transient (|java.lang.Thread$State|) /|java.lang.Thread$State.NEW|\;
    transient (|java.lang.Thread$State|) /|java.lang.Thread$State.RUNNABLE|\;
    transient (|java.lang.Thread$State|) /|java.lang.Thread$State.BLOCKED|\;
    transient (|java.lang.Thread$State|) /|java.lang.Thread$State.WAITING|\;
    transient (|java.lang.Thread$State|) /|java.lang.Thread$State.TIMED_WAITING|\;
    transient (|java.lang.Thread$State|) /|java.lang.Thread$State.TERMINATED|\;
    function {|java.lang.Thread$State.()V|}(VM.F f)
    {

        loc l0:
            do independent
            {
                /|java.lang.Thread$State.NEW|\ := new (|java.lang.Thread$State|);
                /|java.lang.Thread$State.RUNNABLE|\ := new (|java.lang.Thread$State|);
                /|java.lang.Thread$State.BLOCKED|\ := new (|java.lang.Thread$State|);
                /|java.lang.Thread$State.WAITING|\ := new (|java.lang.Thread$State|);
                /|java.lang.Thread$State.TIMED_WAITING|\ := new (|java.lang.Thread$State|);
                /|java.lang.Thread$State.TERMINATED|\ := new (|java.lang.Thread$State|);
                /|java.lang.Thread$State.NEW|\.name := "NEW";
                /|java.lang.Thread$State.RUNNABLE|\.name := "RUNNABLE";
                /|java.lang.Thread$State.BLOCKED|\.name := "BLOCKED";
                /|java.lang.Thread$State.WAITING|\.name := "WAITING";
                /|java.lang.Thread$State.TIMED_WAITING|\.name := "TIMED_WAITING";
                /|java.lang.Thread$State.TERMINATED|\.name := "TERMINATED";
                (Thread.trd()).state := /|java.lang.Thread$State.RUNNABLE|\;
            }
            return;
    }
    throwable record (|java.lang.Throwable|) extends (|java.lang.Object|) { string msg;(|java.lang.Throwable|) t; }
    typealias byte int wrap (-128, 127);
    typealias short int wrap (-32768, 32767);
    typealias char int wrap (0, 0xffff);
    throwable record UnsupportedNativeMethodBogorError {}
    const Op { ACONST_NULL = 1; ICONST_M1 = 2; ICONST_0 = 3; ICONST_1 = 4; ICONST_2 = 5; ICONST_3 = 6; ICONST_4 = 7; ICONST_5 = 8; LCONST_0 = 9; LCONST_1 = 10; FCONST_0 = 11; FCONST_1 = 12; FCONST_2 = 13; DCONST_0 = 14; DCONST_1 = 15; BIPUSH = 16; SIPUSH = 17; LDC = 18; ILOAD = 21; LLOAD = 22; FLOAD = 23; DLOAD = 24; ALOAD = 25; IALOAD = 46; LALOAD = 47; FALOAD = 48; DALOAD = 49; AALOAD = 50; BALOAD = 51; CALOAD = 52; SALOAD = 53; ISTORE = 54; LSTORE = 55; FSTORE = 56; DSTORE = 57; ASTORE = 58; IASTORE = 79; LASTORE = 80; FASTORE = 81; DASTORE = 82; AASTORE = 83; BASTORE = 84; CASTORE = 85; SASTORE = 86; POP = 87; POP2 = 88; DUP = 89; DUP_X1 = 90; DUP_X2 = 91; DUP2 = 92; DUP2_X1 = 93; DUP2_X2 = 94; SWAP = 95; IADD = 96; LADD = 97; FADD = 98; DADD = 99; ISUB = 100; LSUB = 101; FSUB = 102; DSUB = 103; IMUL = 104; LMUL = 105; FMUL = 106; DMUL = 107; IDIV = 108; LDIV = 109; FDIV = 110; DDIV = 111; IREM = 112; LREM = 113; FREM = 114; DREM = 115; INEG = 116; LNEG = 117; FNEG = 118; DNEG = 119; ISHL = 120; LSHL = 121; ISHR = 122; LSHR = 123; IUSHR = 124; LUSHR = 125; IAND = 126; LAND = 127; IOR = 128; LOR = 129; IXOR = 130; LXOR = 131; IINC = 132; I2L = 133; I2F = 134; I2D = 135; L2I = 136; L2F = 137; L2D = 138; F2I = 139; F2L = 140; F2D = 141; D2I = 142; D2L = 143; D2F = 144; I2B = 145; I2C = 146; I2S = 147; LCMP = 148; FCMPL = 149; FCMPG = 150; DCMPL = 151; DCMPG = 152; EQ = 153; NE = 154; LT = 155; GE = 156; GT = 157; LE = 158; ICMPEQ = 159; ICMPNE = 160; ICMPLT = 161; ICMPGE = 162; ICMPGT = 163; ICMPLE = 164; ACMPEQ = 165; ACMPNE = 166; GETSTATIC = 178; PUTSTATIC = 179; GETFIELD = 180; PUTFIELD = 181; NEW = 187; NEWARRAY = 188; ANEWARRAY = 189; ARRAYLENGTH = 190; CHECKCAST = 192; INSTANCEOF = 193; MULTIANEWARRAY = 197; NULL = 198; NONNULL = 199; }
    const ATYP { BOOLEAN = 4; CHAR = 5; FLOAT = 6; DOUBLE = 7; BYTE = 8; SHORT = 9; INT = 10; LONG = 11; }
    extension VM for edu.ksu.cis.projects.bogor.vm.module.VM
    {
        typedef F;
        actiondef nwF (lazy VM.F result, int nargs, VM.F...);
        actiondef max (VM.F frame, int localSize, int stackSize);
        actiondef set <'a>(VM.F frame, string localName, int localIndex);
        actiondef unset (VM.F frame, int localIndex);
        expdef 'a tpS <'a>(VM.F frame);
        expdef 'a getS <'a>(VM.F frame, int index);
        expdef 'a getL <'a>(VM.F frame, int index);
        actiondef psh <'a>(VM.F frame, 'a);
        actiondef pop <'a>(VM.F frame, lazy 'a result);
        actiondef rmv (VM.F frame, int...);
        actiondef zro (VM.F frame, int op);
        actiondef one (VM.F frame, int op, int);
        actiondef lcl (VM.F frame, int op, int localIndex);
        actiondef fld (VM.F frame, int op, string fieldName);
        actiondef typ <'a>(VM.F frame, int op);
        actiondef cmp (VM.F frame, int op, lazy boolean result);
        actiondef arr <'a>(VM.F frame, int dims);
        actiondef inc (VM.F frame, int var, int inc);
        expdef int chooseIntRange (int begin, int ends);
        actiondef arrayCopy <'a>('a src, int srcBegin, int length, 'a dest, int dstBegin);
    }
    extension Reflect for edu.ksu.cis.projects.bogor.vm.module.Reflect
    {
        ptypedef type<'a>;
        expdef 'a spure <'a>(string className, string methodName, 'a...);
        expdef 'a pure2 <'a, 'b>(string className, string methodName, boolean isStatic, 'b);
        expdef 'a pure3 <'a, 'b, 'c>(string className, string methodName, boolean isStatic, 'b, 'c);
        expdef 'a pure4 <'a, 'b, 'c, 'd>(string className, string methodName, boolean isStatic, 'b, 'c, 'd);
        expdef 'a pure5 <'a, 'b, 'c, 'd, 'e>(string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e);
        expdef 'a pure6 <'a, 'b, 'c, 'd, 'e, 'f>(string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e, 'f);
        expdef 'a pure7 <'a, 'b, 'c, 'd, 'e, 'f, 'g>(string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e, 'f, 'g);
        expdef 'a pure8 <'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h>(string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e, 'f, 'g, 'h);
        expdef 'a pure9 <'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i>(string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i);
        actiondef apure1 <'a>(lazy Reflect.type<'a>  result, string className, string methodName, boolean isStatic);
        actiondef apure2 <'a, 'b>(lazy Reflect.type<'a>  result, string className, string methodName, boolean isStatic, 'b);
        actiondef apure3 <'a, 'b, 'c>(lazy Reflect.type<'a>  result, string className, string methodName, boolean isStatic, 'b, 'c);
        actiondef apure4 <'a, 'b, 'c, 'd>(lazy Reflect.type<'a>  result, string className, string methodName, boolean isStatic, 'b, 'c, 'd);
        actiondef apure5 <'a, 'b, 'c, 'd, 'e>(lazy Reflect.type<'a>  result, string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e);
        actiondef apure6 <'a, 'b, 'c, 'd, 'e, 'f>(lazy Reflect.type<'a>  result, string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e, 'f);
        actiondef apure7 <'a, 'b, 'c, 'd, 'e, 'f, 'g>(lazy Reflect.type<'a>  result, string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e, 'f, 'g);
        actiondef apure8 <'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h>(lazy Reflect.type<'a>  result, string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e, 'f, 'g, 'h);
        actiondef apure9 <'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i>(lazy Reflect.type<'a>  result, string className, string methodName, boolean isStatic, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i);
        actiondef effect2 <'a, 'b>(lazy 'a result, string className, string methodName, 'b, string bClassName, string bMethodName);
        actiondef effect3 <'a, 'b, 'c>(lazy 'a result, string className, string methodName, 'b, 'c, string bClassName, string bMethodName);
        actiondef effect4 <'a, 'b, 'c, 'd>(lazy 'a result, string className, string methodName, 'b, 'c, 'd, string bClassName, string bMethodName);
        actiondef effect5 <'a, 'b, 'c, 'd, 'e>(lazy 'a result, string className, string methodName, 'b, 'c, 'd, 'e, string bClassName, string bMethodName);
        actiondef effect6 <'a, 'b, 'c, 'd, 'e, 'f>(lazy 'a result, string className, string methodName, 'b, 'c, 'd, 'e, 'f, string bClassName, string bMethodName);
        actiondef effect7 <'a, 'b, 'c, 'd, 'e, 'f, 'g>(lazy 'a result, string className, string methodName, 'b, 'c, 'd, 'e, 'f, 'g, string bClassName, string bMethodName);
        actiondef effect8 <'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h>(lazy 'a result, string className, string methodName, 'b, 'c, 'd, 'e, 'f, 'g, 'h, string bClassName, string bMethodName);
        actiondef effect9 <'a, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i>(lazy 'a result, string className, string methodName, 'b, 'c, 'd, 'e, 'f, 'g, 'h, 'i, string bClassName, string bMethodName);
    }

}