/*****************************************************
 * jr generated file
 ****************************************************/
import edu.ucdavis.jr.*;
import edu.ucdavis.jr.jrx.*;
import java.rmi.*;
import java.io.Serializable;


public class main extends java.lang.Object {
    { JRinit(); }
    
    public main() {
        // Begin Expr2
        super();
        JRprocess();
    }
    
    public static void main(String[] args) {
        InStatObj JRInstmt4 = new InStatObj(3, false);
        CoStatObj JRCostmt4 = new CoStatObj(2, new boolean [] {false, false});
        InStatObj JRInstmt3 = new InStatObj(3, false);
        CoStatObj JRCostmt3 = new CoStatObj(2, new boolean [] {false, false});
        InStatObj JRInstmt2 = new InStatObj(3, false);
        CoStatObj JRCostmt2 = new CoStatObj(2, new boolean [] {false, false});
        InStatObj JRInstmt1 = new InStatObj(3, false);
        CoStatObj JRCostmt1 = new CoStatObj(2, new boolean [] {false, false});
        InStatObj JRInstmt0 = new InStatObj(2, false);
        CoStatObj JRCostmt0 = new CoStatObj(1, new boolean [] {false});
        Object foo = new Foo();
        // Begin JRCall
        // Begin Expr2
        (new Cap_ext_((((Foo)((Foo)foo))).JRget_op_go_intTovoid(), "void")).call(jrvm.getTimestamp(), new java.lang.Object [] {111});// End JRCall
        
        // costmt without quantifier
        int JR_co_0_totalInvs = 0;

        // intialize fretop for each costmt
        JRCostmt0.JR_co_fretop_voidTovoid = new Cap_ext_(new Op_ext_.JRProxyOp(InOp_ext_impl.create()), "void");

        /*missing*/// inni for costmt
        JRLoop0:for (int JR_CO_COUNT_0 = 0; JR_CO_COUNT_0 < 1; JR_CO_COUNT_0++) {
        {
            // Inni Statement without quantifier
            JRInstmt0.armArray[0] = new QuantRec(JRCostmt0.JR_co_retop[0][0], 0, 0);
            JRInstmt0.armArray[1] = new QuantRec(JRCostmt0.JR_co_fretop_voidTovoid, 1, 1);
            JRInstmt0.lock();
            // Equivalence Class has been created and locked
            JRInstmt0.serviced = false;
            _label_JRInstmt0: do
            {
                Invocation JRfinalInvoc0 = null;
                // find THE invocation and service it
                JRInstmt0.gatherAndSortTimes();
                for (JRInstmt0.i = 0;
                    (JRInstmt0.i < JRInstmt0.N) && !JRInstmt0.serviced;
                     JRInstmt0.i++)
                {
                    JRInstmt0.byStrt = true;
                    JRInstmt0.releaseIter();
                    // if the op is empty
                    if (JRInstmt0.timesArray[JRInstmt0.i].time < 0) continue;
                    switch (JRInstmt0.timesArray[JRInstmt0.i].opNum)
                    {
                        case 0:
                        {
                            JRInstmt0.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec0 = (QuantRec)JRInstmt0.armArray[JRInstmt0.timesArray[JRInstmt0.i].armArrayIndex];
                            Recv_ext JRrrecv0 = null, JRtmprecv0;
                            
                            for (JRInstmt0.iter = JRInstmt0.armArray[JRInstmt0.timesArray[JRInstmt0.i].armArrayIndex].theCap.elements();
                                 JRInstmt0.iter.hasNext();)
                            {
                                JRtmprecv0 = (Recv_ext)JRInstmt0.iter.next();
                                JRInstmt0.JRinit.setInvoc(JRInstmt0.j++);
                                JRtmprecv0.setInvocation(JRInstmt0.JRinit);
                                // extract values
                                JRrrecv0 = JRtmprecv0;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv0 != null)
                            {
                                JRInstmt0.j = (int)JRrrecv0.getInvoc();
                                JRInstmt0.serviced = true;
                                JRInstmt0.iter.remove(JRInstmt0.j);
                                JRInstmt0.releaseIter();
                                JRInstmt0.unlock();
                                
                            }
                            else
                                JRInstmt0.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        case 1:
                        {
                            JRInstmt0.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec0 = (QuantRec)JRInstmt0.armArray[JRInstmt0.timesArray[JRInstmt0.i].armArrayIndex];
                            Recv_ext JRrrecv0 = null, JRtmprecv0;
                            for (JRInstmt0.iter = JRInstmt0.armArray[JRInstmt0.timesArray[JRInstmt0.i].armArrayIndex].theCap.elements();
                                 JRInstmt0.iter.hasNext();)
                            {
                                JRtmprecv0 = (Recv_ext)JRInstmt0.iter.next();
                                JRInstmt0.JRinit.setInvoc(JRInstmt0.j++);
                                JRtmprecv0.setInvocation(JRInstmt0.JRinit);
                                // extract values
                                JRrrecv0 = JRtmprecv0;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv0 != null)
                            {
                                JRInstmt0.j = (int)JRrrecv0.getInvoc();
                                JRInstmt0.serviced = true;
                                JRInstmt0.iter.remove(JRInstmt0.j);
                                JRInstmt0.releaseIter();
                                JRInstmt0.unlock();
                                
                            }
                            else
                                JRInstmt0.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        
                    }
                }
                if (!JRInstmt0.serviced)
                {
                    // must block and loop
                    JRInstmt0.waitOnLock();
                }
            } while (!JRInstmt0.serviced);
        }
        // End Inni
        }
        
        // costmt without quantifier
        int JR_co_1_totalInvs = 0;

        // intialize fretop for each costmt
        JRCostmt1.JR_co_fretop_voidTovoid = new Cap_ext_(new Op_ext_.JRProxyOp(InOp_ext_impl.create()), "void");

        /*missing*//*missing*/// inni for costmt
        JRLoop1:for (int JR_CO_COUNT_1 = 0; JR_CO_COUNT_1 < 2; JR_CO_COUNT_1++) {
        {
            // Inni Statement without quantifier
            JRInstmt1.armArray[0] = new QuantRec(JRCostmt1.JR_co_retop[0][0], 0, 0);
            JRInstmt1.armArray[1] = new QuantRec(JRCostmt1.JR_co_retop[1][0], 1, 1);
            JRInstmt1.armArray[2] = new QuantRec(JRCostmt1.JR_co_fretop_voidTovoid, 2, 2);
            JRInstmt1.lock();
            // Equivalence Class has been created and locked
            JRInstmt1.serviced = false;
            _label_JRInstmt1: do
            {
                Invocation JRfinalInvoc1 = null;
                // find THE invocation and service it
                JRInstmt1.gatherAndSortTimes();
                for (JRInstmt1.i = 0;
                    (JRInstmt1.i < JRInstmt1.N) && !JRInstmt1.serviced;
                     JRInstmt1.i++)
                {
                    JRInstmt1.byStrt = true;
                    JRInstmt1.releaseIter();
                    // if the op is empty
                    if (JRInstmt1.timesArray[JRInstmt1.i].time < 0) continue;
                    switch (JRInstmt1.timesArray[JRInstmt1.i].opNum)
                    {
                        case 0:
                        {
                            JRInstmt1.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec1 = (QuantRec)JRInstmt1.armArray[JRInstmt1.timesArray[JRInstmt1.i].armArrayIndex];
                            Recv_ext JRrrecv1 = null, JRtmprecv1;
                            
                            for (JRInstmt1.iter = JRInstmt1.armArray[JRInstmt1.timesArray[JRInstmt1.i].armArrayIndex].theCap.elements();
                                 JRInstmt1.iter.hasNext();)
                            {
                                JRtmprecv1 = (Recv_ext)JRInstmt1.iter.next();
                                JRInstmt1.JRinit.setInvoc(JRInstmt1.j++);
                                JRtmprecv1.setInvocation(JRInstmt1.JRinit);
                                // extract values
                                JRrrecv1 = JRtmprecv1;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv1 != null)
                            {
                                JRInstmt1.j = (int)JRrrecv1.getInvoc();
                                JRInstmt1.serviced = true;
                                JRInstmt1.iter.remove(JRInstmt1.j);
                                JRInstmt1.releaseIter();
                                JRInstmt1.unlock();
                                
                            }
                            else
                                JRInstmt1.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        case 1:
                        {
                            JRInstmt1.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec1 = (QuantRec)JRInstmt1.armArray[JRInstmt1.timesArray[JRInstmt1.i].armArrayIndex];
                            Recv_ext JRrrecv1 = null, JRtmprecv1;
                            
                            for (JRInstmt1.iter = JRInstmt1.armArray[JRInstmt1.timesArray[JRInstmt1.i].armArrayIndex].theCap.elements();
                                 JRInstmt1.iter.hasNext();)
                            {
                                JRtmprecv1 = (Recv_ext)JRInstmt1.iter.next();
                                JRInstmt1.JRinit.setInvoc(JRInstmt1.j++);
                                JRtmprecv1.setInvocation(JRInstmt1.JRinit);
                                // extract values
                                JRrrecv1 = JRtmprecv1;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv1 != null)
                            {
                                JRInstmt1.j = (int)JRrrecv1.getInvoc();
                                JRInstmt1.serviced = true;
                                JRInstmt1.iter.remove(JRInstmt1.j);
                                JRInstmt1.releaseIter();
                                JRInstmt1.unlock();
                                
                            }
                            else
                                JRInstmt1.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        case 2:
                        {
                            JRInstmt1.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec1 = (QuantRec)JRInstmt1.armArray[JRInstmt1.timesArray[JRInstmt1.i].armArrayIndex];
                            Recv_ext JRrrecv1 = null, JRtmprecv1;
                            for (JRInstmt1.iter = JRInstmt1.armArray[JRInstmt1.timesArray[JRInstmt1.i].armArrayIndex].theCap.elements();
                                 JRInstmt1.iter.hasNext();)
                            {
                                JRtmprecv1 = (Recv_ext)JRInstmt1.iter.next();
                                JRInstmt1.JRinit.setInvoc(JRInstmt1.j++);
                                JRtmprecv1.setInvocation(JRInstmt1.JRinit);
                                // extract values
                                JRrrecv1 = JRtmprecv1;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv1 != null)
                            {
                                JRInstmt1.j = (int)JRrrecv1.getInvoc();
                                JRInstmt1.serviced = true;
                                JRInstmt1.iter.remove(JRInstmt1.j);
                                JRInstmt1.releaseIter();
                                JRInstmt1.unlock();
                                
                            }
                            else
                                JRInstmt1.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        
                    }
                }
                if (!JRInstmt1.serviced)
                {
                    // must block and loop
                    JRInstmt1.waitOnLock();
                }
            } while (!JRInstmt1.serviced);
        }
        // End Inni
        }
        
        // costmt without quantifier
        int JR_co_2_totalInvs = 0;

        // intialize fretop for each costmt
        JRCostmt2.JR_co_fretop_voidTovoid = new Cap_ext_(new Op_ext_.JRProxyOp(InOp_ext_impl.create()), "void");

        /*missing*//*missing*/// inni for costmt
        JRLoop2:for (int JR_CO_COUNT_2 = 0; JR_CO_COUNT_2 < 2; JR_CO_COUNT_2++) {
        {
            // Inni Statement without quantifier
            JRInstmt2.armArray[0] = new QuantRec(JRCostmt2.JR_co_retop[0][0], 0, 0);
            JRInstmt2.armArray[1] = new QuantRec(JRCostmt2.JR_co_retop[1][0], 1, 1);
            JRInstmt2.armArray[2] = new QuantRec(JRCostmt2.JR_co_fretop_voidTovoid, 2, 2);
            JRInstmt2.lock();
            // Equivalence Class has been created and locked
            JRInstmt2.serviced = false;
            _label_JRInstmt2: do
            {
                Invocation JRfinalInvoc2 = null;
                // find THE invocation and service it
                JRInstmt2.gatherAndSortTimes();
                for (JRInstmt2.i = 0;
                    (JRInstmt2.i < JRInstmt2.N) && !JRInstmt2.serviced;
                     JRInstmt2.i++)
                {
                    JRInstmt2.byStrt = true;
                    JRInstmt2.releaseIter();
                    // if the op is empty
                    if (JRInstmt2.timesArray[JRInstmt2.i].time < 0) continue;
                    switch (JRInstmt2.timesArray[JRInstmt2.i].opNum)
                    {
                        case 0:
                        {
                            JRInstmt2.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec2 = (QuantRec)JRInstmt2.armArray[JRInstmt2.timesArray[JRInstmt2.i].armArrayIndex];
                            Recv_ext JRrrecv2 = null, JRtmprecv2;
                            
                            for (JRInstmt2.iter = JRInstmt2.armArray[JRInstmt2.timesArray[JRInstmt2.i].armArrayIndex].theCap.elements();
                                 JRInstmt2.iter.hasNext();)
                            {
                                JRtmprecv2 = (Recv_ext)JRInstmt2.iter.next();
                                JRInstmt2.JRinit.setInvoc(JRInstmt2.j++);
                                JRtmprecv2.setInvocation(JRInstmt2.JRinit);
                                // extract values
                                JRrrecv2 = JRtmprecv2;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv2 != null)
                            {
                                JRInstmt2.j = (int)JRrrecv2.getInvoc();
                                JRInstmt2.serviced = true;
                                JRInstmt2.iter.remove(JRInstmt2.j);
                                JRInstmt2.releaseIter();
                                JRInstmt2.unlock();
                                
                            }
                            else
                                JRInstmt2.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        case 1:
                        {
                            JRInstmt2.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec2 = (QuantRec)JRInstmt2.armArray[JRInstmt2.timesArray[JRInstmt2.i].armArrayIndex];
                            Recv_ext JRrrecv2 = null, JRtmprecv2;
                            
                            for (JRInstmt2.iter = JRInstmt2.armArray[JRInstmt2.timesArray[JRInstmt2.i].armArrayIndex].theCap.elements();
                                 JRInstmt2.iter.hasNext();)
                            {
                                JRtmprecv2 = (Recv_ext)JRInstmt2.iter.next();
                                JRInstmt2.JRinit.setInvoc(JRInstmt2.j++);
                                JRtmprecv2.setInvocation(JRInstmt2.JRinit);
                                // extract values
                                JRrrecv2 = JRtmprecv2;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv2 != null)
                            {
                                JRInstmt2.j = (int)JRrrecv2.getInvoc();
                                JRInstmt2.serviced = true;
                                JRInstmt2.iter.remove(JRInstmt2.j);
                                JRInstmt2.releaseIter();
                                JRInstmt2.unlock();
                                
                            }
                            else
                                JRInstmt2.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        case 2:
                        {
                            JRInstmt2.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec2 = (QuantRec)JRInstmt2.armArray[JRInstmt2.timesArray[JRInstmt2.i].armArrayIndex];
                            Recv_ext JRrrecv2 = null, JRtmprecv2;
                            for (JRInstmt2.iter = JRInstmt2.armArray[JRInstmt2.timesArray[JRInstmt2.i].armArrayIndex].theCap.elements();
                                 JRInstmt2.iter.hasNext();)
                            {
                                JRtmprecv2 = (Recv_ext)JRInstmt2.iter.next();
                                JRInstmt2.JRinit.setInvoc(JRInstmt2.j++);
                                JRtmprecv2.setInvocation(JRInstmt2.JRinit);
                                // extract values
                                JRrrecv2 = JRtmprecv2;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv2 != null)
                            {
                                JRInstmt2.j = (int)JRrrecv2.getInvoc();
                                JRInstmt2.serviced = true;
                                JRInstmt2.iter.remove(JRInstmt2.j);
                                JRInstmt2.releaseIter();
                                JRInstmt2.unlock();
                                
                            }
                            else
                                JRInstmt2.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        
                    }
                }
                if (!JRInstmt2.serviced)
                {
                    // must block and loop
                    JRInstmt2.waitOnLock();
                }
            } while (!JRInstmt2.serviced);
        }
        // End Inni
        }
        
        // costmt without quantifier
        int JR_co_3_totalInvs = 0;

        // intialize fretop for each costmt
        JRCostmt3.JR_co_fretop_voidTovoid = new Cap_ext_(new Op_ext_.JRProxyOp(InOp_ext_impl.create()), "void");

        /*missing*//*missing*/// inni for costmt
        JRLoop3:for (int JR_CO_COUNT_3 = 0; JR_CO_COUNT_3 < 2; JR_CO_COUNT_3++) {
        {
            // Inni Statement without quantifier
            JRInstmt3.armArray[0] = new QuantRec(JRCostmt3.JR_co_retop[0][0], 0, 0);
            JRInstmt3.armArray[1] = new QuantRec(JRCostmt3.JR_co_retop[1][0], 1, 1);
            JRInstmt3.armArray[2] = new QuantRec(JRCostmt3.JR_co_fretop_voidTovoid, 2, 2);
            JRInstmt3.lock();
            // Equivalence Class has been created and locked
            JRInstmt3.serviced = false;
            _label_JRInstmt3: do
            {
                Invocation JRfinalInvoc3 = null;
                // find THE invocation and service it
                JRInstmt3.gatherAndSortTimes();
                for (JRInstmt3.i = 0;
                    (JRInstmt3.i < JRInstmt3.N) && !JRInstmt3.serviced;
                     JRInstmt3.i++)
                {
                    JRInstmt3.byStrt = true;
                    JRInstmt3.releaseIter();
                    // if the op is empty
                    if (JRInstmt3.timesArray[JRInstmt3.i].time < 0) continue;
                    switch (JRInstmt3.timesArray[JRInstmt3.i].opNum)
                    {
                        case 0:
                        {
                            JRInstmt3.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec3 = (QuantRec)JRInstmt3.armArray[JRInstmt3.timesArray[JRInstmt3.i].armArrayIndex];
                            Recv_ext JRrrecv3 = null, JRtmprecv3;
                            
                            for (JRInstmt3.iter = JRInstmt3.armArray[JRInstmt3.timesArray[JRInstmt3.i].armArrayIndex].theCap.elements();
                                 JRInstmt3.iter.hasNext();)
                            {
                                JRtmprecv3 = (Recv_ext)JRInstmt3.iter.next();
                                JRInstmt3.JRinit.setInvoc(JRInstmt3.j++);
                                JRtmprecv3.setInvocation(JRInstmt3.JRinit);
                                // extract values
                                JRrrecv3 = JRtmprecv3;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv3 != null)
                            {
                                JRInstmt3.j = (int)JRrrecv3.getInvoc();
                                JRInstmt3.serviced = true;
                                JRInstmt3.iter.remove(JRInstmt3.j);
                                JRInstmt3.releaseIter();
                                JRInstmt3.unlock();
                                
                            }
                            else
                                JRInstmt3.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        case 1:
                        {
                            JRInstmt3.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec3 = (QuantRec)JRInstmt3.armArray[JRInstmt3.timesArray[JRInstmt3.i].armArrayIndex];
                            Recv_ext JRrrecv3 = null, JRtmprecv3;
                            
                            for (JRInstmt3.iter = JRInstmt3.armArray[JRInstmt3.timesArray[JRInstmt3.i].armArrayIndex].theCap.elements();
                                 JRInstmt3.iter.hasNext();)
                            {
                                JRtmprecv3 = (Recv_ext)JRInstmt3.iter.next();
                                JRInstmt3.JRinit.setInvoc(JRInstmt3.j++);
                                JRtmprecv3.setInvocation(JRInstmt3.JRinit);
                                // extract values
                                JRrrecv3 = JRtmprecv3;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv3 != null)
                            {
                                JRInstmt3.j = (int)JRrrecv3.getInvoc();
                                JRInstmt3.serviced = true;
                                JRInstmt3.iter.remove(JRInstmt3.j);
                                JRInstmt3.releaseIter();
                                JRInstmt3.unlock();
                                
                            }
                            else
                                JRInstmt3.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        case 2:
                        {
                            JRInstmt3.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec3 = (QuantRec)JRInstmt3.armArray[JRInstmt3.timesArray[JRInstmt3.i].armArrayIndex];
                            Recv_ext JRrrecv3 = null, JRtmprecv3;
                            for (JRInstmt3.iter = JRInstmt3.armArray[JRInstmt3.timesArray[JRInstmt3.i].armArrayIndex].theCap.elements();
                                 JRInstmt3.iter.hasNext();)
                            {
                                JRtmprecv3 = (Recv_ext)JRInstmt3.iter.next();
                                JRInstmt3.JRinit.setInvoc(JRInstmt3.j++);
                                JRtmprecv3.setInvocation(JRInstmt3.JRinit);
                                // extract values
                                JRrrecv3 = JRtmprecv3;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv3 != null)
                            {
                                JRInstmt3.j = (int)JRrrecv3.getInvoc();
                                JRInstmt3.serviced = true;
                                JRInstmt3.iter.remove(JRInstmt3.j);
                                JRInstmt3.releaseIter();
                                JRInstmt3.unlock();
                                
                            }
                            else
                                JRInstmt3.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        
                    }
                }
                if (!JRInstmt3.serviced)
                {
                    // must block and loop
                    JRInstmt3.waitOnLock();
                }
            } while (!JRInstmt3.serviced);
        }
        // End Inni
        }
        
        // costmt without quantifier
        int JR_co_4_totalInvs = 0;

        // intialize fretop for each costmt
        JRCostmt4.JR_co_fretop_voidTovoid = new Cap_ext_(new Op_ext_.JRProxyOp(InOp_ext_impl.create()), "void");

        /*missing*//*missing*/// inni for costmt
        JRLoop4:for (int JR_CO_COUNT_4 = 0; JR_CO_COUNT_4 < 2; JR_CO_COUNT_4++) {
        {
            // Inni Statement without quantifier
            JRInstmt4.armArray[0] = new QuantRec(JRCostmt4.JR_co_retop[0][0], 0, 0);
            JRInstmt4.armArray[1] = new QuantRec(JRCostmt4.JR_co_retop[1][0], 1, 1);
            JRInstmt4.armArray[2] = new QuantRec(JRCostmt4.JR_co_fretop_voidTovoid, 2, 2);
            JRInstmt4.lock();
            // Equivalence Class has been created and locked
            JRInstmt4.serviced = false;
            _label_JRInstmt4: do
            {
                Invocation JRfinalInvoc4 = null;
                // find THE invocation and service it
                JRInstmt4.gatherAndSortTimes();
                for (JRInstmt4.i = 0;
                    (JRInstmt4.i < JRInstmt4.N) && !JRInstmt4.serviced;
                     JRInstmt4.i++)
                {
                    JRInstmt4.byStrt = true;
                    JRInstmt4.releaseIter();
                    // if the op is empty
                    if (JRInstmt4.timesArray[JRInstmt4.i].time < 0) continue;
                    switch (JRInstmt4.timesArray[JRInstmt4.i].opNum)
                    {
                        case 0:
                        {
                            JRInstmt4.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec4 = (QuantRec)JRInstmt4.armArray[JRInstmt4.timesArray[JRInstmt4.i].armArrayIndex];
                            Recv_ext JRrrecv4 = null, JRtmprecv4;
                            
                            for (JRInstmt4.iter = JRInstmt4.armArray[JRInstmt4.timesArray[JRInstmt4.i].armArrayIndex].theCap.elements();
                                 JRInstmt4.iter.hasNext();)
                            {
                                JRtmprecv4 = (Recv_ext)JRInstmt4.iter.next();
                                JRInstmt4.JRinit.setInvoc(JRInstmt4.j++);
                                JRtmprecv4.setInvocation(JRInstmt4.JRinit);
                                // extract values
                                JRrrecv4 = JRtmprecv4;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv4 != null)
                            {
                                JRInstmt4.j = (int)JRrrecv4.getInvoc();
                                JRInstmt4.serviced = true;
                                JRInstmt4.iter.remove(JRInstmt4.j);
                                JRInstmt4.releaseIter();
                                JRInstmt4.unlock();
                                
                            }
                            else
                                JRInstmt4.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        case 1:
                        {
                            JRInstmt4.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec4 = (QuantRec)JRInstmt4.armArray[JRInstmt4.timesArray[JRInstmt4.i].armArrayIndex];
                            Recv_ext JRrrecv4 = null, JRtmprecv4;
                            
                            for (JRInstmt4.iter = JRInstmt4.armArray[JRInstmt4.timesArray[JRInstmt4.i].armArrayIndex].theCap.elements();
                                 JRInstmt4.iter.hasNext();)
                            {
                                JRtmprecv4 = (Recv_ext)JRInstmt4.iter.next();
                                JRInstmt4.JRinit.setInvoc(JRInstmt4.j++);
                                JRtmprecv4.setInvocation(JRInstmt4.JRinit);
                                // extract values
                                JRrrecv4 = JRtmprecv4;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv4 != null)
                            {
                                JRInstmt4.j = (int)JRrrecv4.getInvoc();
                                JRInstmt4.serviced = true;
                                JRInstmt4.iter.remove(JRInstmt4.j);
                                JRInstmt4.releaseIter();
                                JRInstmt4.unlock();
                                
                            }
                            else
                                JRInstmt4.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        case 2:
                        {
                            JRInstmt4.j = 0;
                            // Inni Arm
                            QuantRec JRquantRec4 = (QuantRec)JRInstmt4.armArray[JRInstmt4.timesArray[JRInstmt4.i].armArrayIndex];
                            Recv_ext JRrrecv4 = null, JRtmprecv4;
                            for (JRInstmt4.iter = JRInstmt4.armArray[JRInstmt4.timesArray[JRInstmt4.i].armArrayIndex].theCap.elements();
                                 JRInstmt4.iter.hasNext();)
                            {
                                JRtmprecv4 = (Recv_ext)JRInstmt4.iter.next();
                                JRInstmt4.JRinit.setInvoc(JRInstmt4.j++);
                                JRtmprecv4.setInvocation(JRInstmt4.JRinit);
                                // extract values
                                JRrrecv4 = JRtmprecv4;
                                break;  // get first one
                            }
                            // Start of servicing
                            if (JRrrecv4 != null)
                            {
                                JRInstmt4.j = (int)JRrrecv4.getInvoc();
                                JRInstmt4.serviced = true;
                                JRInstmt4.iter.remove(JRInstmt4.j);
                                JRInstmt4.releaseIter();
                                JRInstmt4.unlock();
                                
                            }
                            else
                                JRInstmt4.releaseIter();
                            // End of servicing
                            // End InniArm
                            break;
                        }
                        
                    }
                }
                if (!JRInstmt4.serviced)
                {
                    // must block and loop
                    JRInstmt4.waitOnLock();
                }
            } while (!JRInstmt4.serviced);
        }
        // End Inni
        }
        
        // Begin Expr2
        System.out.println("after all co");
    }
    protected boolean JRcalled = false;
    protected JRmain jrresref;
    public Object JRgetjrresref()
    { try {return jrresref.clone(); } catch (Exception e) {/* not gonna happen */ return null; } }
    protected void JRinit() {
    	if(this.JRcalled) return;
    	jrresref = new JRmain();
    	this.JRcalled = true;
    }
    private boolean JRproc = false;
    private void JRprocess() {
    	if (JRproc) return;
    	JRproc = true;
    }
}
