package run;

import jp.sync.Barrier;

import java.util.Vector;

import jp.lang.*;



public class Worker extends jp.lang.RemoteObject
  implements Runnable, Resident
{

  /**
   * Transport descriptor for class Worker.
   */
  public static final uka.transport.TransportDescriptor TRANSPORT_DESCRIPTOR =
    new uka.transport.TransportDescriptor() {
      public Object unmarshalReference(uka.transport.UnmarshalStream s, int id)
        throws java.io.IOException, ClassNotFoundException
      {
        return new Worker(s, id);
      }

      public boolean unmarshal(Object obj, uka.transport.UnmarshalStream s)
        throws ClassNotFoundException, java.io.IOException
      {
        ((Worker) obj).unmarshal(s);
        return true;
      }

      public void marshalReference(Object obj, uka.transport.MarshalStream s)
        throws java.io.IOException
      {
        ((Worker) obj).marshalReference(s);
      }

      public void marshal(Object obj, uka.transport.MarshalStream s)
        throws java.io.IOException
      {
        ((Worker) obj).marshal(s);
      }

      public Object deepClone(Object orig, int id, uka.transport.DeepClone _helper)
        throws CloneNotSupportedException
      {
        return orig;
      }

      public boolean deepCloneReferences(Object orig, Object copy, uka.transport.DeepClone _helper)
        throws CloneNotSupportedException
      {
        return false;
      }

      public void restoreAfterUnmarshal(Object obj)
        throws ClassNotFoundException, java.io.IOException
      {
        ((Worker) obj).externalRestoreAfterUnmarshal();
      }

      public Class getType() {
        return Worker.class;
      }
    };

  public uka.transport.TransportDescriptor getTransportDescriptor() {
    return TRANSPORT_DESCRIPTOR;
  }

  /**
   * Called from uka.transport.UnmarshalStream to create
   * a transportable object.
   */
  public Worker(uka.transport.UnmarshalStream _stream, int _id)
    throws java.io.IOException, ClassNotFoundException
  {
    super(_stream, _id);
  }

  /** Forwarding constructor. Handle constructors are 'final'. That
      means they need only the functionality of the remote base classes
      constructor. To prevent the execution of application defined super
      constructors, this forwarding constructor is generated in each
      handle class and called from all constructors of subclasses. */
  protected Worker(jp.lang.Marker dummy) {
    super(dummy);
  }

  /** Remote static variable access: get Worker._class */
  public static final Worker_class_intf run_Worker__class_get_()  {
    try {
      return _class.run_Worker__class_get_();
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker__class_get_()", _e);
    }
  }

  /** Replicated static constant '_class' */
  public static final Worker_class_intf _class = Worker_class_impl._class;

  /** Remote variable access: get Worker.temporary_element */
  public final run.Element run_Worker_temporary_element_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (run.Element) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_temporary_element_get_());
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_temporary_element_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (run.Element) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_temporary_element_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.temporary_element */
  public final run.Element run_Worker_temporary_element_set_(run.Element _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (run.Element) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_temporary_element_set_((run.Element) _cenv.doDeepClone(_value_)));
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_temporary_element_set_$run_Element);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.sendObject(_value_);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (run.Element) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_temporary_element_set_(run.Element _value_)", _e);
    }
  }

  /** Remote variable access: get Worker.temporary_node */
  public final run.Node run_Worker_temporary_node_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (run.Node) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_temporary_node_get_());
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_temporary_node_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (run.Node) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_temporary_node_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.temporary_node */
  public final run.Node run_Worker_temporary_node_set_(run.Node _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (run.Node) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_temporary_node_set_((run.Node) _cenv.doDeepClone(_value_)));
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_temporary_node_set_$run_Node);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.sendObject(_value_);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (run.Node) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_temporary_node_set_(run.Node _value_)", _e);
    }
  }

  /** Remote variable access: get Worker.elementlist */
  public final java.util.Vector run_Worker_elementlist_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (java.util.Vector) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_elementlist_get_());
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_elementlist_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (java.util.Vector) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_elementlist_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.elementlist */
  public final java.util.Vector run_Worker_elementlist_set_(java.util.Vector _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (java.util.Vector) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_elementlist_set_((java.util.Vector) _cenv.doDeepClone(_value_)));
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_elementlist_set_$java_util_Vector);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.sendObject(_value_);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (java.util.Vector) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_elementlist_set_(java.util.Vector _value_)", _e);
    }
  }

  /** Remote variable access: get Worker.nodelist */
  public final java.util.Vector run_Worker_nodelist_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (java.util.Vector) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_nodelist_get_());
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_nodelist_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (java.util.Vector) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_nodelist_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.nodelist */
  public final java.util.Vector run_Worker_nodelist_set_(java.util.Vector _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (java.util.Vector) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_nodelist_set_((java.util.Vector) _cenv.doDeepClone(_value_)));
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_nodelist_set_$java_util_Vector);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.sendObject(_value_);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (java.util.Vector) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_nodelist_set_(java.util.Vector _value_)", _e);
    }
  }

  /** Remote variable access: get Worker.barrier */
  public final jp.sync.Barrier run_Worker_barrier_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (jp.sync.Barrier) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_barrier_get_());
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_barrier_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (jp.sync.Barrier) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_barrier_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.barrier */
  public final jp.sync.Barrier run_Worker_barrier_set_(jp.sync.Barrier _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          return (jp.sync.Barrier) _cenv.doDeepClone(((run.Worker_instance_impl) remoteServer).run_Worker_barrier_set_((jp.sync.Barrier) _cenv.doDeepClone(_value_)));
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_barrier_set_$jp_sync_Barrier);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.sendObject(_value_);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return (jp.sync.Barrier) _c.receiveObject();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_barrier_set_(jp.sync.Barrier _value_)", _e);
    }
  }

  /** Remote variable access: get Worker.time */
  public final double run_Worker_time_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_time_get_();
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_time_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_time_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.time */
  public final double run_Worker_time_set_(double _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_time_set_(_value_);
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_time_set_$double);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(8);
          _c.sendDouble(_value_);
          _c.closeSendPrimitive(8);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_time_set_(double _value_)", _e);
    }
  }

  /** Remote variable access: increment Worker.time */
  public final double run_Worker_time_inc_(double _value_, boolean _post_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_time_inc_(_value_, _post_);
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_time_inc_$double$boolean);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(9);
          _c.sendDouble(_value_);
          _c.sendBoolean(_post_);
          _c.closeSendPrimitive(9);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_time_inc_(double _value_, boolean _post_)", _e);
    }
  }

  /** Remote variable access: get Worker.timestep */
  public final double run_Worker_timestep_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_timestep_get_();
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_timestep_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_timestep_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.timestep */
  public final double run_Worker_timestep_set_(double _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_timestep_set_(_value_);
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_timestep_set_$double);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(8);
          _c.sendDouble(_value_);
          _c.closeSendPrimitive(8);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_timestep_set_(double _value_)", _e);
    }
  }

  /** Remote variable access: increment Worker.timestep */
  public final double run_Worker_timestep_inc_(double _value_, boolean _post_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_timestep_inc_(_value_, _post_);
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_timestep_inc_$double$boolean);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(9);
          _c.sendDouble(_value_);
          _c.sendBoolean(_post_);
          _c.closeSendPrimitive(9);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_timestep_inc_(double _value_, boolean _post_)", _e);
    }
  }

  /** Remote variable access: get Worker.ttemp */
  public final double run_Worker_ttemp_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_ttemp_get_();
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_ttemp_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_ttemp_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.ttemp */
  public final double run_Worker_ttemp_set_(double _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_ttemp_set_(_value_);
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_ttemp_set_$double);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(8);
          _c.sendDouble(_value_);
          _c.closeSendPrimitive(8);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_ttemp_set_(double _value_)", _e);
    }
  }

  /** Remote variable access: increment Worker.ttemp */
  public final double run_Worker_ttemp_inc_(double _value_, boolean _post_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_ttemp_inc_(_value_, _post_);
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_ttemp_inc_$double$boolean);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(9);
          _c.sendDouble(_value_);
          _c.sendBoolean(_post_);
          _c.closeSendPrimitive(9);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_ttemp_inc_(double _value_, boolean _post_)", _e);
    }
  }

  /** Remote variable access: get Worker.keep_running */
  public final boolean run_Worker_keep_running_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_keep_running_get_();
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_keep_running_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleBoolean();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_keep_running_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.keep_running */
  public final boolean run_Worker_keep_running_set_(boolean _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_keep_running_set_(_value_);
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_keep_running_set_$boolean);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(1);
          _c.sendBoolean(_value_);
          _c.closeSendPrimitive(1);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleBoolean();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_keep_running_set_(boolean _value_)", _e);
    }
  }

  /** Remote variable access: get Worker.autostep */
  public final boolean run_Worker_autostep_get_()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_autostep_get_();
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_autostep_get_$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleBoolean();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_autostep_get_()", _e);
    }
  }

  /** Remote variable access: set Worker.autostep */
  public final boolean run_Worker_autostep_set_(boolean _value_)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).run_Worker_autostep_set_(_value_);
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run_Worker_autostep_set_$boolean);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(1);
          _c.sendBoolean(_value_);
          _c.closeSendPrimitive(1);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleBoolean();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run_Worker_autostep_set_(boolean _value_)", _e);
    }
  }

  /** Handle constructor of class 'Worker'. This constructor
      initiates Remote object instantiation. It uses the
      RuntimeEnvironment to decide about the remote node, on
      which the object will be allocated. */
  public Worker(Barrier barrier, double time, double timestep, boolean autostep)  {
    super((jp.lang.Marker) null);
    try {
      // look up the remote constructor object
      Worker_class_intf constr = (Worker_class_intf)
        jp.lang.RuntimeEnvironment.getConstrObj("run.Worker");

      // create the remote implementation
      java.lang.Object _ref = constr._new(barrier, time, timestep, autostep);

      // assign the remote reference
      _KARMI_setRemoteClientRef((uka.karmi.rmi.RemoteClientRef) _ref);
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker(Barrier barrier, double time, double timestep, boolean autostep)", _e);
    }
  }

  /** Handle constructor of class 'Worker'. This constructor
      initiates Remote object instantiation. It uses the
      RuntimeEnvironment to decide about the remote node, on
      which the object will be allocated. */
  public Worker(jp.lang.Node _node, Barrier barrier, double time, double timestep, boolean autostep)  {
    super((jp.lang.Marker) null);
    try {
      // look up the remote constructor object
      Worker_class_intf constr = (Worker_class_intf)
        jp.lang.RuntimeEnvironment.getConstrObj("run.Worker", _node.getMachineID());

      // create the remote implementation
      java.lang.Object _ref = constr._new(barrier, time, timestep, autostep);

      // assign the remote reference
      _KARMI_setRemoteClientRef((uka.karmi.rmi.RemoteClientRef) _ref);
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker(Barrier barrier, double time, double timestep, boolean autostep)", _e);
    }
  }

  /** Application method of class Worker */
  public void addElement(run.Element el)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          ((run.Worker_instance_impl) remoteServer).addElement((run.Element) _cenv.doDeepClone(el));
          return;
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_addElement$run_Element);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.sendObject(el);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return;
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.addElement(run.Element el)", _e);
    }
  }

  /** Application method of class Worker */
  public void removeElement(run.Element el)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          ((run.Worker_instance_impl) remoteServer).removeElement((run.Element) _cenv.doDeepClone(el));
          return;
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_removeElement$run_Element);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.sendObject(el);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return;
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.removeElement(run.Element el)", _e);
    }
  }

  /** Application method of class Worker */
  public void addNode(run.Node node)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          ((run.Worker_instance_impl) remoteServer).addNode((run.Node) _cenv.doDeepClone(node));
          return;
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_addNode$run_Node);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.sendObject(node);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return;
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.addNode(run.Node node)", _e);
    }
  }

  /** Application method of class Worker */
  public void removeNode(run.Node node)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        uka.karmi.rmi.CopyEnvironment _cenv = uka.karmi.rmi.Transport.getCopyEnvironment();
        try {
          ((run.Worker_instance_impl) remoteServer).removeNode((run.Node) _cenv.doDeepClone(node));
          return;
        } catch (CloneNotSupportedException ex) {
          throw new uka.karmi.rmi.RemoteException("KaRMIc: arg or result not clonable", ex);
        } finally {
          uka.karmi.rmi.Transport.putCopyEnvironment(_cenv);
        }
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_removeNode$run_Node);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.sendObject(node);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return;
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.removeNode(run.Node node)", _e);
    }
  }

  /** Application method of class Worker */
  public void run()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        ((run.Worker_instance_impl) remoteServer).run();
        return;
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_run$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return;
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.run()", _e);
    }
  }

  /** Application method of class Worker */
  public void setKeep_running(boolean keep_running)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        ((run.Worker_instance_impl) remoteServer).setKeep_running(keep_running);
        return;
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_setKeep_running$boolean);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(1);
          _c.sendBoolean(keep_running);
          _c.closeSendPrimitive(1);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return;
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.setKeep_running(boolean keep_running)", _e);
    }
  }

  /** Application method of class Worker */
  public double getTime()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).getTime();
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_getTime$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.getTime()", _e);
    }
  }

  /** Application method of class Worker */
  public void setTime(double time)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        ((run.Worker_instance_impl) remoteServer).setTime(time);
        return;
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_setTime$double);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(8);
          _c.sendDouble(time);
          _c.closeSendPrimitive(8);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return;
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.setTime(double time)", _e);
    }
  }

  /** Application method of class Worker */
  public double getTimestep()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).getTimestep();
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_getTimestep$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.getTimestep()", _e);
    }
  }

  /** Application method of class Worker */
  public void setTimestep(double timestep)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        ((run.Worker_instance_impl) remoteServer).setTimestep(timestep);
        return;
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_setTimestep$double);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(8);
          _c.sendDouble(timestep);
          _c.closeSendPrimitive(8);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return;
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.setTimestep(double timestep)", _e);
    }
  }

  /** Application method of class Worker */
  public double getTtemp()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).getTtemp();
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_getTtemp$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleDouble();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.getTtemp()", _e);
    }
  }

  /** Application method of class Worker */
  public boolean isAutostep()  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        return ((run.Worker_instance_impl) remoteServer).isAutostep();
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_isAutostep$);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return _c.receiveSingleBoolean();
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.isAutostep()", _e);
    }
  }

  /** Application method of class Worker */
  public void setAutostep(boolean autostep)  {
    try {
      // KaRMI inlined stub code 
      if (remoteServer != null) {
        // short cut: call server implementation directly
        ((run.Worker_instance_impl) remoteServer).setAutostep(autostep);
        return;
      } else {
        uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.Worker_instance_impl_KStub.ID_setAutostep$boolean);

        Throwable resultex;
        try {
          _c.openSendCall();
          _c.openSendPrimitive(1);
          _c.sendBoolean(autostep);
          _c.closeSendPrimitive(1);
          _c.closeSendCall();

          boolean _normalReturn = _c.openReceiveResult();
          try {
            if (_normalReturn) {
              return;
            } else {
              resultex = (Throwable) _c.receiveObject();
            }
          } finally {
            _c.closeReceiveResult();
          }
        } catch (ClassNotFoundException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: unmarshal problem", ex);
        } catch (uka.karmi.rmi.RemoteException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (java.io.IOException ex) {
          _c.closeExceptionally();
          throw new uka.karmi.rmi.RemoteException("KaRMI: transport problem", ex);
        } catch (RuntimeException ex) {
          _c.closeExceptionally();
          throw ex;
        } catch (Error ex) {
          _c.closeExceptionally();
          throw ex;
        }

        // rethrow runtime exceptions and declared exceptions
        if (resultex instanceof java.lang.Error) {
          throw (java.lang.Error) resultex;
        }
        if (resultex instanceof java.lang.RuntimeException) {
          throw (java.lang.RuntimeException) resultex;
        }
        // exception not possible here
        throw new InternalError("KaRMI: exception not declared: " + resultex);
      }
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("Worker.setAutostep(boolean autostep)", _e);
    }
  }

}
