system .|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock|.
{
    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.deadlock.d1.Deadlock.main([Ljava/lang/String;)V|}(f$) return;
    }
    record (|java.lang.Thread$UncaughtExceptionHandler|) extends (|java.lang.Object|) {}
    (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock|) /|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.lock1|\;
    (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock|) /|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.lock2|\;
    int /|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.state|\;
    record (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock|) extends (|java.lang.Object|) {}
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.main([Ljava/lang/String;)V|}(VM.F f)
    {
        VM.F f$;

        loc l0$13:
            do independent
            {
                VM.max(f, 3, 2);
                VM.set<(|java.lang.String|)[]>(f, "args", 0);
                VM.typ<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock|)>(f, Op.NEW);
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l3;
        loc $l3:
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock.()V|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock|)>(f$, 0), f$) goto l4$13;
        loc l4$13:
            do
            {
                VM.fld(f, Op.PUTSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.lock1|\\");
            }
            goto l5$14;
        loc l5$14:
            do independent
            {
                VM.typ<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock|)>(f, Op.NEW);
            }
            goto l6;
        loc l6:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l7;
        loc l7:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l8;
        loc $l8:
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock.()V|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock|)>(f$, 0), f$) goto l9$14;
        loc l9$14:
            do
            {
                VM.fld(f, Op.PUTSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.lock2|\\");
            }
            goto l10$15;
        loc l10$15:
            do independent
            {
                VM.typ<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|)>(f, Op.NEW);
            }
            goto l11;
        loc l11:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l12;
        loc l12:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l13;
        loc $l13:
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1.()V|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|)>(f$, 0), f$) goto l14$15;
        loc l14$15:
            do independent
            {
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|)>(f, "p1", 1);
                VM.lcl(f, Op.ASTORE, 1);
            }
            goto l15$16;
        loc l15$16:
            do independent
            {
                VM.typ<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|)>(f, Op.NEW);
            }
            goto l16;
        loc l16:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l17;
        loc l17:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l18;
        loc $l18:
            independent invoke {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2.()V|}(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|)>(f$, 0), f$) goto l19$16;
        loc l19$16:
            do independent
            {
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|)>(f, "p2", 2);
                VM.lcl(f, Op.ASTORE, 2);
            }
            goto l20$17;
        loc l20$17:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l21;
        loc l21:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l22$17;
        loc $l22$17:
            independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1.start()V|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|)>(f$, 0), f$) goto l23$18;
        loc l23$18:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l24;
        loc l24:
            do independent
            {
                VM.nwF(f$, 1, f);
            }
            goto $l25$18;
        loc $l25$18:
            independent invoke virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2.start()V|+(VM.getL<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|)>(f$, 0), f$) goto l26$19;
        loc l26$19:
            do independent
            {
            }
            return;
    }
    record (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock|) extends (|java.lang.Object|) {}
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock.()V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock|) this, VM.F f)
    {
        VM.F f$;

        loc l0$54:
            do independent
            {
                VM.max(f, 1, 1);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Lock|)>(f, "this", 0);
                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|}(VM.getL<(|java.lang.Object|)>(f$, 0), f$) goto l3$54;
        loc l3$54:
            do independent
            {
            }
            return;
    }
    record (|java.lang.reflect.Type|) extends (|java.lang.Object|) {}
    record (|java.lang.reflect.AnnotatedElement|) extends (|java.lang.Object|) {}
    record (|java.lang.Comparable|) extends (|java.lang.Object|) {}
    record (|java.lang.CharSequence|) extends (|java.lang.Object|) {}
    record (|java.lang.Runnable|) extends (|java.lang.Object|) {}
    record (|java.lang.reflect.GenericDeclaration|) extends (|java.lang.Object|) {}
    record (|java.io.Serializable|) extends (|java.lang.Object|) {}
    record (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|) extends (|java.lang.Thread|) {}
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1.()V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|) this, VM.F f)
    {
        VM.F f$;

        loc l0$22:
            do independent
            {
                VM.max(f, 1, 1);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|)>(f, "this", 0);
                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.Thread.()V|}(VM.getL<(|java.lang.Thread|)>(f$, 0), f$) goto l3$22;
        loc l3$22:
            do independent
            {
            }
            return;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1.run()V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|) this, VM.F f)
    {
        (|java.lang.Throwable|) t;
        (|java.lang.Object|) o;
        (|java.lang.Thread|) th;

        loc l0$27:
            do
            {
                VM.max(f, 3, 2);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|)>(f, "this", 0);
                VM.fld(f, Op.GETSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.state|\\");
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.zro(f, Op.ICONST_1);
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.zro(f, Op.IADD);
            }
            goto l3$27;
        loc l3$27:
            do
            {
                VM.fld(f, Op.PUTSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.state|\\");
            }
            goto l4$28;
        loc l4$28:
            do
            {
                VM.fld(f, Op.GETSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.lock1|\\");
            }
            goto l5;
        loc l5:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l6;
        loc l6:
            do independent
            {
                VM.lcl(f, Op.ASTORE, 1);
            }
            goto l7;
        loc l7:
            do independent
            {
                th := Thread.trd();
                assert th.state == /|java.lang.Thread$State.RUNNABLE|\;
                o := VM.tpS<(|java.lang.Object|)>(f);
            }
            goto $l8$28;
        loc $l8$28:
            when o == null || lockAvailable(o.l) do
            {
                lock(o.l);
                VM.rmv(f);
                th.state := /|java.lang.Thread$State.RUNNABLE|\;
            }
            goto l9$30;
            when !(o == null || lockAvailable(o.l)) && th.state != /|java.lang.Thread$State.BLOCKED|\ do independent
            {
                th.state := /|java.lang.Thread$State.BLOCKED|\;
            }
            goto $l8$28;
        loc l9$30:
            do
            {
                VM.fld(f, Op.GETSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.lock2|\\");
            }
            goto l10;
        loc l10:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l11;
        loc l11:
            do independent
            {
                VM.lcl(f, Op.ASTORE, 2);
            }
            goto l12;
        loc l12:
            do independent
            {
                th := Thread.trd();
                assert th.state == /|java.lang.Thread$State.RUNNABLE|\;
                o := VM.tpS<(|java.lang.Object|)>(f);
            }
            goto $l13$30;
        loc $l13$30:
            when o == null || lockAvailable(o.l) do
            {
                lock(o.l);
                VM.rmv(f);
                th.state := /|java.lang.Thread$State.RUNNABLE|\;
            }
            goto l14$32;
            when !(o == null || lockAvailable(o.l)) && th.state != /|java.lang.Thread$State.BLOCKED|\ do independent
            {
                th.state := /|java.lang.Thread$State.BLOCKED|\;
            }
            goto $l13$30;
        loc l14$32:
            do
            {
                VM.fld(f, Op.GETSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.state|\\");
            }
            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$32;
        loc l17$32:
            do
            {
                VM.fld(f, Op.PUTSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.state|\\");
            }
            goto l18$30;
        loc l18$30:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l19$30;
        loc l19$30:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l20$30;
        loc l20$30:
            do independent
            {
            }
            goto l24$28;
        loc l21$30:
            do independent
            {
                VM.psh<(|java.lang.Throwable|)>(f, t);
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l22$30;
        loc l22$30:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l23$30;
        loc l23$30:
            do independent
            {
                VM.pop<(|java.lang.Throwable|)>(f, t);
                throw t;
            }
            goto l23$30;
        loc l24$28:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l25$28;
        loc l25$28:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l26$28;
        loc l26$28:
            do independent
            {
            }
            goto l30$35;
        loc l27$28:
            do independent
            {
                VM.psh<(|java.lang.Throwable|)>(f, t);
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l28$28;
        loc l28$28:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l29$28;
        loc l29$28:
            do independent
            {
                VM.pop<(|java.lang.Throwable|)>(f, t);
                throw t;
            }
            goto l29$28;
        loc l30$35:
            do independent
            {
            }
            return;
        catch (|java.lang.Throwable|) t at l14$32, l15, l16, l17$32, l18$30, l19$30 goto l21$30;
        catch (|java.lang.Throwable|) t at l21$30, l22$30 goto l21$30;
        catch (|java.lang.Throwable|) t at l9$30, l10, l11, l12, $l13$30, l14$32, l15, l16, l17$32, l18$30, l19$30, l20$30, l21$30, l22$30, l23$30, l24$28, l25$28 goto l27$28;
        catch (|java.lang.Throwable|) t at l27$28, l28$28 goto l27$28;
    }
    record (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|) extends (|java.lang.Thread|) {}
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2.()V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|) this, VM.F f)
    {
        VM.F f$;

        loc l0$38:
            do independent
            {
                VM.max(f, 1, 1);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|)>(f, "this", 0);
                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.Thread.()V|}(VM.getL<(|java.lang.Thread|)>(f$, 0), f$) goto l3$38;
        loc l3$38:
            do independent
            {
            }
            return;
    }
    function {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2.run()V|}(transient (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|) this, VM.F f)
    {
        (|java.lang.Throwable|) t;
        (|java.lang.Object|) o;
        (|java.lang.Thread|) th;

        loc l0$43:
            do
            {
                VM.max(f, 3, 2);
                VM.set<(|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|)>(f, "this", 0);
                VM.fld(f, Op.GETSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.state|\\");
            }
            goto l1;
        loc l1:
            do independent
            {
                VM.zro(f, Op.ICONST_1);
            }
            goto l2;
        loc l2:
            do independent
            {
                VM.zro(f, Op.IADD);
            }
            goto l3$43;
        loc l3$43:
            do
            {
                VM.fld(f, Op.PUTSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.state|\\");
            }
            goto l4$44;
        loc l4$44:
            do
            {
                VM.fld(f, Op.GETSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.lock2|\\");
            }
            goto l5;
        loc l5:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l6;
        loc l6:
            do independent
            {
                VM.lcl(f, Op.ASTORE, 1);
            }
            goto l7;
        loc l7:
            do independent
            {
                th := Thread.trd();
                assert th.state == /|java.lang.Thread$State.RUNNABLE|\;
                o := VM.tpS<(|java.lang.Object|)>(f);
            }
            goto $l8$44;
        loc $l8$44:
            when o == null || lockAvailable(o.l) do
            {
                lock(o.l);
                VM.rmv(f);
                th.state := /|java.lang.Thread$State.RUNNABLE|\;
            }
            goto l9$46;
            when !(o == null || lockAvailable(o.l)) && th.state != /|java.lang.Thread$State.BLOCKED|\ do independent
            {
                th.state := /|java.lang.Thread$State.BLOCKED|\;
            }
            goto $l8$44;
        loc l9$46:
            do
            {
                VM.fld(f, Op.GETSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.lock1|\\");
            }
            goto l10;
        loc l10:
            do independent
            {
                VM.zro(f, Op.DUP);
            }
            goto l11;
        loc l11:
            do independent
            {
                VM.lcl(f, Op.ASTORE, 2);
            }
            goto l12;
        loc l12:
            do independent
            {
                th := Thread.trd();
                assert th.state == /|java.lang.Thread$State.RUNNABLE|\;
                o := VM.tpS<(|java.lang.Object|)>(f);
            }
            goto $l13$46;
        loc $l13$46:
            when o == null || lockAvailable(o.l) do
            {
                lock(o.l);
                VM.rmv(f);
                th.state := /|java.lang.Thread$State.RUNNABLE|\;
            }
            goto l14$48;
            when !(o == null || lockAvailable(o.l)) && th.state != /|java.lang.Thread$State.BLOCKED|\ do independent
            {
                th.state := /|java.lang.Thread$State.BLOCKED|\;
            }
            goto $l13$46;
        loc l14$48:
            do
            {
                VM.fld(f, Op.GETSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.state|\\");
            }
            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$48;
        loc l17$48:
            do
            {
                VM.fld(f, Op.PUTSTATIC, "/|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Deadlock.state|\\");
            }
            goto l18$46;
        loc l18$46:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l19$46;
        loc l19$46:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l20$46;
        loc l20$46:
            do independent
            {
            }
            goto l24$44;
        loc l21$46:
            do independent
            {
                VM.psh<(|java.lang.Throwable|)>(f, t);
                VM.lcl(f, Op.ALOAD, 2);
            }
            goto l22$46;
        loc l22$46:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l23$46;
        loc l23$46:
            do independent
            {
                VM.pop<(|java.lang.Throwable|)>(f, t);
                throw t;
            }
            goto l23$46;
        loc l24$44:
            do independent
            {
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l25$44;
        loc l25$44:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l26$44;
        loc l26$44:
            do independent
            {
            }
            goto l30$51;
        loc l27$44:
            do independent
            {
                VM.psh<(|java.lang.Throwable|)>(f, t);
                VM.lcl(f, Op.ALOAD, 1);
            }
            goto l28$44;
        loc l28$44:
            do independent
            {
                unlock(VM.tpS<(|java.lang.Object|)>(f).l);
                VM.rmv(f);
            }
            goto l29$44;
        loc l29$44:
            do independent
            {
                VM.pop<(|java.lang.Throwable|)>(f, t);
                throw t;
            }
            goto l29$44;
        loc l30$51:
            do independent
            {
            }
            return;
        catch (|java.lang.Throwable|) t at l14$48, l15, l16, l17$48, l18$46, l19$46 goto l21$46;
        catch (|java.lang.Throwable|) t at l21$46, l22$46 goto l21$46;
        catch (|java.lang.Throwable|) t at l9$46, l10, l11, l12, $l13$46, l14$48, l15, l16, l17$48, l18$46, l19$46, l20$46, l21$46, l22$46, l23$46, l24$44, l25$44 goto l27$44;
        catch (|java.lang.Throwable|) t at l27$44, l28$44 goto l27$44;
    }
    virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2.start()V|+ { (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|) -> {|java.lang.Thread.start()V|} }
    virtual +|java.lang.Thread.run()V|+ { (|java.lang.Thread|) -> {|java.lang.Thread.run()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|) -> {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1.run()V|} (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2|) -> {|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process2.run()V|} }
    virtual +|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1.start()V|+ { (|edu.ksu.cis.projects.bogor.vm.translator.test.deadlock.d1.Process1|) -> {|java.lang.Thread.start()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;
    }
    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);
    }

}