package run;

import java.util.*;

import java.io.*;

import run.readers.FembicReader;

import uka.karmi.rmi.RemoteException;

import jp.sync.*;

import jp.lang.*;



public class SmackCluster extends jp.lang.RemoteObject
{

  /**
   * Transport descriptor for class SmackCluster.
   */
  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 SmackCluster(s, id);
      }

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

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

      public void marshal(Object obj, uka.transport.MarshalStream s)
        throws java.io.IOException
      {
        ((SmackCluster) 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
      {
        ((SmackCluster) obj).externalRestoreAfterUnmarshal();
      }

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

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

  /**
   * Called from uka.transport.UnmarshalStream to create
   * a transportable object.
   */
  public SmackCluster(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 SmackCluster(jp.lang.Marker dummy) {
    super(dummy);
  }

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

  /** Replicated static constant '_class' */
  public static final SmackCluster_class_intf _class = SmackCluster_class_impl._class;

  /** Remote variable access: get SmackCluster.number_of_elements */
  public final int run_SmackCluster_number_of_elements_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_elements_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_elements_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_elements_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.number_of_elements */
  public final int run_SmackCluster_number_of_elements_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_elements_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_elements_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_elements_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_elements */
  public final int run_SmackCluster_number_of_elements_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_elements_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_elements_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_elements_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.number_of_trackers */
  public final int run_SmackCluster_number_of_trackers_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_trackers_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_trackers_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_trackers_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.number_of_trackers */
  public final int run_SmackCluster_number_of_trackers_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_trackers_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_trackers_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_trackers_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_trackers */
  public final int run_SmackCluster_number_of_trackers_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_trackers_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_trackers_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_trackers_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.number_of_nodes */
  public final int run_SmackCluster_number_of_nodes_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_nodes_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_nodes_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_nodes_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.number_of_nodes */
  public final int run_SmackCluster_number_of_nodes_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_nodes_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_nodes_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_nodes_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_nodes */
  public final int run_SmackCluster_number_of_nodes_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_nodes_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_nodes_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_nodes_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.number_of_materials */
  public final int run_SmackCluster_number_of_materials_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_materials_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_materials_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_materials_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.number_of_materials */
  public final int run_SmackCluster_number_of_materials_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_materials_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_materials_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_materials_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_materials */
  public final int run_SmackCluster_number_of_materials_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_materials_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_materials_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_materials_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.number_of_controls */
  public final int run_SmackCluster_number_of_controls_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_controls_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_controls_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_controls_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.number_of_controls */
  public final int run_SmackCluster_number_of_controls_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_controls_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_controls_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_controls_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_controls */
  public final int run_SmackCluster_number_of_controls_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_controls_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_controls_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_controls_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.number_of_constraints */
  public final int run_SmackCluster_number_of_constraints_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_constraints_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_constraints_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_constraints_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.number_of_constraints */
  public final int run_SmackCluster_number_of_constraints_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_constraints_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_constraints_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_constraints_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_constraints */
  public final int run_SmackCluster_number_of_constraints_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_constraints_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_constraints_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_constraints_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.number_of_loads */
  public final int run_SmackCluster_number_of_loads_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_loads_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_loads_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_loads_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.number_of_loads */
  public final int run_SmackCluster_number_of_loads_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_loads_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_loads_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_loads_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.number_of_loads */
  public final int run_SmackCluster_number_of_loads_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_number_of_loads_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_number_of_loads_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_number_of_loads_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.constraintlist */
  public final run.RplVector run_SmackCluster_constraintlist_get_()  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_constraintlist_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_constraintlist_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_constraintlist_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.constraintlist */
  public final run.RplVector run_SmackCluster_constraintlist_set_(run.RplVector _value_)  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_constraintlist_set_((run.RplVector) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_constraintlist_set_$run_RplVector);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_constraintlist_set_(run.RplVector _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.loadlist */
  public final run.RplVector run_SmackCluster_loadlist_get_()  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_loadlist_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_loadlist_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_loadlist_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.loadlist */
  public final run.RplVector run_SmackCluster_loadlist_set_(run.RplVector _value_)  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_loadlist_set_((run.RplVector) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_loadlist_set_$run_RplVector);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_loadlist_set_(run.RplVector _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.nodelist */
  public final run.RplVector run_SmackCluster_nodelist_get_()  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nodelist_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nodelist_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.nodelist */
  public final run.RplVector run_SmackCluster_nodelist_set_(run.RplVector _value_)  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_nodelist_set_((run.RplVector) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nodelist_set_$run_RplVector);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nodelist_set_(run.RplVector _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.elementlist */
  public final run.RplVector run_SmackCluster_elementlist_get_()  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_elementlist_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_elementlist_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.elementlist */
  public final run.RplVector run_SmackCluster_elementlist_set_(run.RplVector _value_)  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_elementlist_set_((run.RplVector) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_elementlist_set_$run_RplVector);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_elementlist_set_(run.RplVector _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.trackerlist */
  public final run.RplVector run_SmackCluster_trackerlist_get_()  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_trackerlist_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_trackerlist_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_trackerlist_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.trackerlist */
  public final run.RplVector run_SmackCluster_trackerlist_set_(run.RplVector _value_)  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_trackerlist_set_((run.RplVector) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_trackerlist_set_$run_RplVector);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_trackerlist_set_(run.RplVector _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.materiallist */
  public final run.RplVector run_SmackCluster_materiallist_get_()  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_materiallist_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_materiallist_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_materiallist_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.materiallist */
  public final run.RplVector run_SmackCluster_materiallist_set_(run.RplVector _value_)  {
    while (true) {
      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.RplVector) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_materiallist_set_((run.RplVector) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_materiallist_set_$run_RplVector);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.RplVector) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_materiallist_set_(run.RplVector _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.time */
  public final double run_SmackCluster_time_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_time_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_time_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.time */
  public final double run_SmackCluster_time_set_(double _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_time_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_time_set_(double _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.time */
  public final double run_SmackCluster_time_inc_(double _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_time_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_time_inc_(double _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.ttemp */
  public final double run_SmackCluster_ttemp_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_ttemp_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_ttemp_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.ttemp */
  public final double run_SmackCluster_ttemp_set_(double _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_ttemp_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_ttemp_set_(double _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.ttemp */
  public final double run_SmackCluster_ttemp_inc_(double _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_ttemp_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_ttemp_inc_(double _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.exported_ttemp */
  public final double run_SmackCluster_exported_ttemp_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_exported_ttemp_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_exported_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_exported_ttemp_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.exported_ttemp */
  public final double run_SmackCluster_exported_ttemp_set_(double _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_exported_ttemp_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_exported_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_exported_ttemp_set_(double _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.exported_ttemp */
  public final double run_SmackCluster_exported_ttemp_inc_(double _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_exported_ttemp_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_exported_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_exported_ttemp_inc_(double _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.i */
  public final int run_SmackCluster_i_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_i_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_i_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_i_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.i */
  public final int run_SmackCluster_i_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_i_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_i_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_i_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.i */
  public final int run_SmackCluster_i_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_i_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_i_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_i_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.controlset */
  public final run.Controlset run_SmackCluster_controlset_get_()  {
    while (true) {
      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.Controlset) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_controlset_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_controlset_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.Controlset) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_controlset_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.controlset */
  public final run.Controlset run_SmackCluster_controlset_set_(run.Controlset _value_)  {
    while (true) {
      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.Controlset) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_controlset_set_((run.Controlset) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_controlset_set_$run_Controlset);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.Controlset) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_controlset_set_(run.Controlset _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.temporary_element */
  public final run.Element run_SmackCluster_temporary_element_get_()  {
    while (true) {
      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.SmackCluster_instance_impl) remoteServer).run_SmackCluster_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_temporary_element_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.temporary_element */
  public final run.Element run_SmackCluster_temporary_element_set_(run.Element _value_)  {
    while (true) {
      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.SmackCluster_instance_impl) remoteServer).run_SmackCluster_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_temporary_element_set_(run.Element _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.temporary_tracker */
  public final run.Tracker run_SmackCluster_temporary_tracker_get_()  {
    while (true) {
      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.Tracker) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_temporary_tracker_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_temporary_tracker_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.Tracker) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_temporary_tracker_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.temporary_tracker */
  public final run.Tracker run_SmackCluster_temporary_tracker_set_(run.Tracker _value_)  {
    while (true) {
      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.Tracker) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_temporary_tracker_set_((run.Tracker) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_temporary_tracker_set_$run_Tracker);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.Tracker) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_temporary_tracker_set_(run.Tracker _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.temporary_constraint */
  public final run.Constraint run_SmackCluster_temporary_constraint_get_()  {
    while (true) {
      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.Constraint) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_temporary_constraint_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_temporary_constraint_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.Constraint) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_temporary_constraint_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.temporary_constraint */
  public final run.Constraint run_SmackCluster_temporary_constraint_set_(run.Constraint _value_)  {
    while (true) {
      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.Constraint) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_temporary_constraint_set_((run.Constraint) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_temporary_constraint_set_$run_Constraint);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.Constraint) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_temporary_constraint_set_(run.Constraint _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.temporary_node */
  public final run.Node run_SmackCluster_temporary_node_get_()  {
    while (true) {
      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.SmackCluster_instance_impl) remoteServer).run_SmackCluster_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_temporary_node_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.temporary_node */
  public final run.Node run_SmackCluster_temporary_node_set_(run.Node _value_)  {
    while (true) {
      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.SmackCluster_instance_impl) remoteServer).run_SmackCluster_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_temporary_node_set_(run.Node _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.resultwriter */
  public final run.Writer run_SmackCluster_resultwriter_get_()  {
    while (true) {
      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.Writer) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_resultwriter_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_resultwriter_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.Writer) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_resultwriter_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.resultwriter */
  public final run.Writer run_SmackCluster_resultwriter_set_(run.Writer _value_)  {
    while (true) {
      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.Writer) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_resultwriter_set_((run.Writer) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_resultwriter_set_$run_Writer);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.Writer) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_resultwriter_set_(run.Writer _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.trackwriter */
  public final run.TrackWriter run_SmackCluster_trackwriter_get_()  {
    while (true) {
      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.TrackWriter) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_trackwriter_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_trackwriter_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.TrackWriter) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_trackwriter_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.trackwriter */
  public final run.TrackWriter run_SmackCluster_trackwriter_set_(run.TrackWriter _value_)  {
    while (true) {
      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.TrackWriter) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_trackwriter_set_((run.TrackWriter) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_trackwriter_set_$run_TrackWriter);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.TrackWriter) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_trackwriter_set_(run.TrackWriter _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.filename */
  public final java.lang.String run_SmackCluster_filename_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_filename_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_filename_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (java.lang.String) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_filename_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.filename */
  public final java.lang.String run_SmackCluster_filename_set_(java.lang.String _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_filename_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_filename_set_$java_lang_String);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (java.lang.String) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_filename_set_(java.lang.String _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.timestep */
  public final double run_SmackCluster_timestep_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_timestep_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_timestep_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.timestep */
  public final double run_SmackCluster_timestep_set_(double _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_timestep_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_timestep_set_(double _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.timestep */
  public final double run_SmackCluster_timestep_inc_(double _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_timestep_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_timestep_inc_(double _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.failure_is_set */
  public final boolean run_SmackCluster_failure_is_set_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_failure_is_set_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_failure_is_set_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_failure_is_set_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.failure_is_set */
  public final boolean run_SmackCluster_failure_is_set_set_(boolean _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_failure_is_set_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_failure_is_set_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_failure_is_set_set_(boolean _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.autostep */
  public final boolean run_SmackCluster_autostep_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_autostep_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_autostep_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.autostep */
  public final boolean run_SmackCluster_autostep_set_(boolean _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_autostep_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_autostep_set_(boolean _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.nr_of_CPUs */
  public final int run_SmackCluster_nr_of_CPUs_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_nr_of_CPUs_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nr_of_CPUs_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nr_of_CPUs_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.nr_of_CPUs */
  public final int run_SmackCluster_nr_of_CPUs_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_nr_of_CPUs_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nr_of_CPUs_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nr_of_CPUs_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.nr_of_CPUs */
  public final int run_SmackCluster_nr_of_CPUs_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_nr_of_CPUs_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nr_of_CPUs_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nr_of_CPUs_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.client_nr */
  public final int run_SmackCluster_client_nr_get_()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_client_nr_get_();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_client_nr_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_client_nr_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.client_nr */
  public final int run_SmackCluster_client_nr_set_(int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_client_nr_set_(_value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_client_nr_set_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(_value_);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_client_nr_set_(int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.client_nr */
  public final int run_SmackCluster_client_nr_inc_(int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_client_nr_inc_(_value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_client_nr_inc_$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_client_nr_inc_(int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.cluster_nodes */
  public final run.SmackCluster[] run_SmackCluster_cluster_nodes_get_()  {
    while (true) {
      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.SmackCluster[]) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_cluster_nodes_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_cluster_nodes_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.SmackCluster[]) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_cluster_nodes_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.cluster_nodes */
  public final run.SmackCluster[] run_SmackCluster_cluster_nodes_set_(run.SmackCluster[] _value_)  {
    while (true) {
      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.SmackCluster[]) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_cluster_nodes_set_((run.SmackCluster[]) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_cluster_nodes_set_$_run_SmackCluster);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.SmackCluster[]) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_cluster_nodes_set_(run.SmackCluster[] _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.cluster_nodes[p0] */
  public final run.SmackCluster run_SmackCluster_cluster_nodes_get_(int p0)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_cluster_nodes_get_(p0);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_cluster_nodes_get_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(p0);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.SmackCluster) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_cluster_nodes_get_(int p0)", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.cluster_nodes[p0] */
  public final run.SmackCluster run_SmackCluster_cluster_nodes_set_(int p0, run.SmackCluster _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_cluster_nodes_set_(p0, _value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_cluster_nodes_set_$int$run_SmackCluster);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(p0);
            _c.closeSendPrimitive(4);
            _c.sendObject(_value_);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (run.SmackCluster) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_cluster_nodes_set_(int p0, run.SmackCluster _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.nodeindicies */
  public final int[] run_SmackCluster_nodeindicies_get_()  {
    while (true) {
      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 (int[]) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_nodeindicies_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nodeindicies_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (int[]) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nodeindicies_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.nodeindicies */
  public final int[] run_SmackCluster_nodeindicies_set_(int[] _value_)  {
    while (true) {
      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 (int[]) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_nodeindicies_set_((int[]) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nodeindicies_set_$_int);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (int[]) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nodeindicies_set_(int[] _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.nodeindicies[p0] */
  public final int run_SmackCluster_nodeindicies_get_(int p0)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_nodeindicies_get_(p0);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nodeindicies_get_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(p0);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nodeindicies_get_(int p0)", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.nodeindicies[p0] */
  public final int run_SmackCluster_nodeindicies_set_(int p0, int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_nodeindicies_set_(p0, _value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nodeindicies_set_$int$int);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nodeindicies_set_(int p0, int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.nodeindicies[p0] */
  public final int run_SmackCluster_nodeindicies_inc_(int p0, int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_nodeindicies_inc_(p0, _value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_nodeindicies_inc_$int$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_nodeindicies_inc_(int p0, int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.elementindicies */
  public final int[] run_SmackCluster_elementindicies_get_()  {
    while (true) {
      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 (int[]) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_elementindicies_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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_elementindicies_get_$);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (int[]) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_elementindicies_get_()", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.elementindicies */
  public final int[] run_SmackCluster_elementindicies_set_(int[] _value_)  {
    while (true) {
      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 (int[]) _cenv.doDeepClone(((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_elementindicies_set_((int[]) _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.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_elementindicies_set_$_int);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return (int[]) _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_elementindicies_set_(int[] _value_)", _e);
      }
    }
  }

  /** Remote variable access: get SmackCluster.elementindicies[p0] */
  public final int run_SmackCluster_elementindicies_get_(int p0)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_elementindicies_get_(p0);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_elementindicies_get_$int);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(4);
            _c.sendInt(p0);
            _c.closeSendPrimitive(4);
            _c.closeSendCall();

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_elementindicies_get_(int p0)", _e);
      }
    }
  }

  /** Remote variable access: set SmackCluster.elementindicies[p0] */
  public final int run_SmackCluster_elementindicies_set_(int p0, int _value_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_elementindicies_set_(p0, _value_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_elementindicies_set_$int$int);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_elementindicies_set_(int p0, int _value_)", _e);
      }
    }
  }

  /** Remote variable access: increment SmackCluster.elementindicies[p0] */
  public final int run_SmackCluster_elementindicies_inc_(int p0, int _value_, boolean _post_)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).run_SmackCluster_elementindicies_inc_(p0, _value_, _post_);
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_run_SmackCluster_elementindicies_inc_$int$int$boolean);

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

            boolean _normalReturn = _c.openReceiveResult();
            try {
              if (_normalReturn) {
                return _c.receiveSingleInt();
              } 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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.run_SmackCluster_elementindicies_inc_(int p0, int _value_, boolean _post_)", _e);
      }
    }
  }

  /** Handle constructor of class 'SmackCluster'. This constructor
      initiates Remote object instantiation. It uses the
      RuntimeEnvironment to decide about the remote node, on
      which the object will be allocated. */
  public SmackCluster(int nr_of_CPUs, int client_nr)  {
    super((jp.lang.Marker) null);
    try {
      // look up the remote constructor object
      SmackCluster_class_intf constr = (SmackCluster_class_intf)
        jp.lang.RuntimeEnvironment.getConstrObj("run.SmackCluster");

      // create the remote implementation
      java.lang.Object _ref = constr._new(nr_of_CPUs, client_nr);

      // assign the remote reference
      _KARMI_setRemoteClientRef((uka.karmi.rmi.RemoteClientRef) _ref);
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("SmackCluster(int nr_of_CPUs, int client_nr)", _e);
    }
  }

  /** Handle constructor of class 'SmackCluster'. This constructor
      initiates Remote object instantiation. It uses the
      RuntimeEnvironment to decide about the remote node, on
      which the object will be allocated. */
  public SmackCluster(jp.lang.Node _node, int nr_of_CPUs, int client_nr)  {
    super((jp.lang.Marker) null);
    try {
      // look up the remote constructor object
      SmackCluster_class_intf constr = (SmackCluster_class_intf)
        jp.lang.RuntimeEnvironment.getConstrObj("run.SmackCluster", _node.getMachineID());

      // create the remote implementation
      java.lang.Object _ref = constr._new(nr_of_CPUs, client_nr);

      // assign the remote reference
      _KARMI_setRemoteClientRef((uka.karmi.rmi.RemoteClientRef) _ref);
    } catch (uka.karmi.rmi.RemoteException _e) {
      throw new jp.lang.RemoteError("SmackCluster(int nr_of_CPUs, int client_nr)", _e);
    }
  }

  /** Application method of class SmackCluster */
  public void assembleMassMatrix() throws java.lang.Error {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          ((run.SmackCluster_instance_impl) remoteServer).assembleMassMatrix();
          return;
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_assembleMassMatrix$);

          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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) 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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.assembleMassMatrix()", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public void initialize(java.lang.String fname, run.SmackCluster[] nodes) throws java.lang.Error, java.lang.Exception {
    while (true) {
      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.SmackCluster_instance_impl) remoteServer).initialize(fname, (run.SmackCluster[]) _cenv.doDeepClone(nodes));
            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.SmackCluster_instance_impl_KStub.ID_initialize$java_lang_String$_run_SmackCluster);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.sendObject(fname);
            _c.sendObject(nodes);
            _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.Exception) {
            throw (java.lang.Exception) resultex;
          }
          // exception not possible here
          throw new InternalError("KaRMI: exception not declared: " + resultex);
        }
      } catch (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.initialize(java.lang.String fname, run.SmackCluster[] nodes)", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public void post()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          ((run.SmackCluster_instance_impl) remoteServer).post();
          return;
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_post$);

          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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.post()", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public void print()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          ((run.SmackCluster_instance_impl) remoteServer).print();
          return;
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_print$);

          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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.print()", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public void setInitialConditions()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          ((run.SmackCluster_instance_impl) remoteServer).setInitialConditions();
          return;
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_setInitialConditions$);

          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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.setInitialConditions()", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public void solve(jp.sync.Barrier barrier) throws java.lang.Exception {
    while (true) {
      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.SmackCluster_instance_impl) remoteServer).solve((jp.sync.Barrier) _cenv.doDeepClone(barrier));
            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.SmackCluster_instance_impl_KStub.ID_solve$jp_sync_Barrier);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.sendObject(barrier);
            _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.Exception) {
            throw (java.lang.Exception) resultex;
          }
          if (resultex instanceof java.lang.Error) {
            throw (java.lang.Error) resultex;
          }
          // exception not possible here
          throw new InternalError("KaRMI: exception not declared: " + resultex);
        }
      } catch (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.solve(jp.sync.Barrier barrier)", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public void passReferences()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          ((run.SmackCluster_instance_impl) remoteServer).passReferences();
          return;
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_passReferences$);

          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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.passReferences()", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public void setReferences(run.RplVector cl, run.RplVector nl, run.RplVector ll, run.RplVector el, run.RplVector ml, run.RplVector tl, run.Controlset cs, run.Writer rw, run.TrackWriter tw, run.SmackCluster[] nod)  {
    while (true) {
      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.SmackCluster_instance_impl) remoteServer).setReferences((run.RplVector) _cenv.doDeepClone(cl), (run.RplVector) _cenv.doDeepClone(nl), (run.RplVector) _cenv.doDeepClone(ll), (run.RplVector) _cenv.doDeepClone(el), (run.RplVector) _cenv.doDeepClone(ml), (run.RplVector) _cenv.doDeepClone(tl), (run.Controlset) _cenv.doDeepClone(cs), (run.Writer) _cenv.doDeepClone(rw), (run.TrackWriter) _cenv.doDeepClone(tw), (run.SmackCluster[]) _cenv.doDeepClone(nod));
            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.SmackCluster_instance_impl_KStub.ID_setReferences$run_RplVector$run_RplVector$run_RplVector$run_RplVector$run_RplVector$run_RplVector$run_Controlset$run_Writer$run_TrackWriter$_run_SmackCluster);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.sendObject(cl);
            _c.sendObject(nl);
            _c.sendObject(ll);
            _c.sendObject(el);
            _c.sendObject(ml);
            _c.sendObject(tl);
            _c.sendObject(cs);
            _c.sendObject(rw);
            _c.sendObject(tw);
            _c.sendObject(nod);
            _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.setReferences(run.RplVector cl, run.RplVector nl, run.RplVector ll, run.RplVector el, run.RplVector ml, run.RplVector tl, run.Controlset cs, run.Writer rw, run.TrackWriter tw, run.SmackCluster[] nod)", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public void setVariables(int noc, int non, int nol, int noe, int nom, int not, int noctrl, double timestep, boolean autostep)  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          ((run.SmackCluster_instance_impl) remoteServer).setVariables(noc, non, nol, noe, nom, not, noctrl, timestep, autostep);
          return;
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_setVariables$int$int$int$int$int$int$int$double$boolean);

          Throwable resultex;
          try {
            _c.openSendCall();
            _c.openSendPrimitive(37);
            _c.sendInt(noc);
            _c.sendInt(non);
            _c.sendInt(nol);
            _c.sendInt(noe);
            _c.sendInt(nom);
            _c.sendInt(not);
            _c.sendInt(noctrl);
            _c.sendDouble(timestep);
            _c.sendBoolean(autostep);
            _c.closeSendPrimitive(37);
            _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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.setVariables(int noc, int non, int nol, int noe, int nom, int not, int noctrl, double timestep, boolean autostep)", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public double getTtemp()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          return ((run.SmackCluster_instance_impl) remoteServer).getTtemp();
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.getTtemp()", _e);
      }
    }
  }

  /** Application method of class SmackCluster */
  public void determineDistribution()  {
    while (true) {
      try {
        // KaRMI inlined stub code 
        if (remoteServer != null) {
          // short cut: call server implementation directly
          ((run.SmackCluster_instance_impl) remoteServer).determineDistribution();
          return;
        } else {
          uka.karmi.rmi.ClientConnection _c = remoteClientRef.getContext(run.SmackCluster_instance_impl_KStub.ID_determineDistribution$);

          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 jp.lang.MovedException) {
            throw (jp.lang.MovedException) resultex;
          }
          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 (jp.lang.MovedException _e) {
        _adaptRef(_e);
      } catch (uka.karmi.rmi.RemoteException _e) {
        throw new jp.lang.RemoteError("SmackCluster.determineDistribution()", _e);
      }
    }
  }

}
