/*
 * This file was generated by orbit-idl - DO NOT EDIT!
 */

#include <string.h>
#include "everything.h"

test_BasicServer
test_TestFactory_getBasicServer(test_TestFactory _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_BasicServer _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->getBasicServer(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[15];
      }
      _ORBIT_operation_name_data =
      {
      15, "getBasicServer"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 19 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_StructServer
test_TestFactory_getStructServer(test_TestFactory _obj,
				 CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_StructServer _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->getStructServer(_obj->servant,
							    ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[16];
      }
      _ORBIT_operation_name_data =
      {
      16, "getStructServer"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 20 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_SequenceServer
test_TestFactory_getSequenceServer(test_TestFactory _obj,
				   CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_SequenceServer _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->getSequenceServer(_obj->servant,
							      ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[18];
      }
      _ORBIT_operation_name_data =
      {
      18, "getSequenceServer"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 22 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_UnionServer
test_TestFactory_getUnionServer(test_TestFactory _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_UnionServer _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->getUnionServer(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[15];
      }
      _ORBIT_operation_name_data =
      {
      15, "getUnionServer"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 19 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_ArrayServer
test_TestFactory_getArrayServer(test_TestFactory _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_ArrayServer _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->getArrayServer(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[15];
      }
      _ORBIT_operation_name_data =
      {
      15, "getArrayServer"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 19 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_AnyServer
test_TestFactory_getAnyServer(test_TestFactory _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_AnyServer _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->getAnyServer(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[13];
      }
      _ORBIT_operation_name_data =
      {
      13, "getAnyServer"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 17 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_BaseServer
test_TestFactory_getBaseServer(test_TestFactory _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_BaseServer _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->getBaseServer(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[14];
      }
      _ORBIT_operation_name_data =
      {
      14, "getBaseServer"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 18 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_DerivedServer
test_TestFactory_getDerivedServer(test_TestFactory _obj,
				  CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_DerivedServer _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->getDerivedServer(_obj->servant,
							     ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[17];
      }
      _ORBIT_operation_name_data =
      {
      17, "getDerivedServer"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 21 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_BaseServer
test_TestFactory_getDerivedServerAsBaseServer(test_TestFactory _obj,
					      CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_BaseServer _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->
	 getDerivedServerAsBaseServer(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[29];
      }
      _ORBIT_operation_name_data =
      {
      29, "getDerivedServerAsBaseServer"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 33 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_B2
test_TestFactory_getDerivedServerAsB2(test_TestFactory _obj,
				      CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_B2 _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->getDerivedServerAsB2(_obj->
								 servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[21];
      }
      _ORBIT_operation_name_data =
      {
      21, "getDerivedServerAsB2"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 25 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_TransientObj
test_TestFactory_createTransientObj(test_TestFactory _obj,
				    CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_TransientObj _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_TestFactory__classid) {
      _ORBIT_retval =
	 ((POA_test_TestFactory__epv *) _obj->
	  vepv[test_TestFactory__classid])->createTransientObj(_obj->servant,
							       ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[19];
      }
      _ORBIT_operation_name_data =
      {
      19, "createTransientObj"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 23 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 _ORBIT_retval =
	    ORBit_demarshal_object(_ORBIT_recv_buffer,
				   GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				   connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
void
test_TransientObj_remove(test_TransientObj _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;

   if (_obj->servant && _obj->vepv && test_TransientObj__classid) {
      ((POA_test_TransientObj__epv *) _obj->
       vepv[test_TransientObj__classid])->remove(_obj->servant, ev);
      return;
   }
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[7];
      }
      _ORBIT_operation_name_data =
      {
      7, "remove"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 11 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return;
      }
   }
}
test_FixedLengthStruct
test_StructServer_opFixed(test_StructServer _obj,
			  const test_FixedLengthStruct * inArg,
			  test_FixedLengthStruct * inoutArg,
			  test_FixedLengthStruct * outArg,
			  CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_FixedLengthStruct _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_StructServer__classid) {
      _ORBIT_retval =
	 ((POA_test_StructServer__epv *) _obj->
	  vepv[test_StructServer__classid])->opFixed(_obj->servant, inArg,
						     inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[8];
      }
      _ORBIT_operation_name_data =
      {
      8, "opFixed"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 12 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 2);
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &((*inArg)), sizeof((*inArg)));
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &((*inoutArg)), sizeof((*inoutArg)));
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	 (*((guint16 *) & (_ORBIT_retval.a))) =
	    GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
	 _ORBIT_curptr += 2;
	 (*((guint16 *) & ((*inoutArg).a))) =
	    GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
	 _ORBIT_curptr += 2;
	 (*((guint16 *) & ((*outArg).a))) =
	    GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	 memcpy(&(_ORBIT_retval), _ORBIT_curptr, sizeof(_ORBIT_retval));
	 _ORBIT_curptr += sizeof(_ORBIT_retval);
	 memcpy(&((*inoutArg)), _ORBIT_curptr, sizeof((*inoutArg)));
	 _ORBIT_curptr += sizeof((*inoutArg));
	 memcpy(&((*outArg)), _ORBIT_curptr, sizeof((*outArg)));
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_VariableLengthStruct *
test_StructServer_opVariable(test_StructServer _obj,
			     const test_VariableLengthStruct * inArg,
			     test_VariableLengthStruct * inoutArg,
			     test_VariableLengthStruct ** outArg,
			     CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_VariableLengthStruct *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_10;
   CORBA_unsigned_long _ORBIT_tmpvar_11;
   register CORBA_unsigned_long _ORBIT_tmpvar_12;
   CORBA_unsigned_long _ORBIT_tmpvar_13;
   register CORBA_unsigned_long _ORBIT_tmpvar_14;
   CORBA_unsigned_long _ORBIT_tmpvar_15;

   if (_obj->servant && _obj->vepv && test_StructServer__classid) {
      _ORBIT_retval =
	 ((POA_test_StructServer__epv *) _obj->
	  vepv[test_StructServer__classid])->opVariable(_obj->servant, inArg,
							inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[11];
      }
      _ORBIT_operation_name_data =
      {
      11, "opVariable"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 15 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      CORBA_unsigned_long _ORBIT_tmpvar_1;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_tmpvar_1 = strlen((*inArg).a) + 1;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof(_ORBIT_tmpvar_1));
      }
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     ((*inArg).a),
				     sizeof((*inArg).a[_ORBIT_tmpvar_0]) *
				     _ORBIT_tmpvar_1);
      _ORBIT_tmpvar_3 = strlen((*inoutArg).a) + 1;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_3));
	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_3), sizeof(_ORBIT_tmpvar_3));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof(_ORBIT_tmpvar_3));
      }
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     ((*inoutArg).a),
				     sizeof((*inoutArg).a[_ORBIT_tmpvar_2]) *
				     _ORBIT_tmpvar_3);
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   test_VariableLengthStruct__free(inoutArg, NULL, CORBA_TRUE);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = test_VariableLengthStruct__alloc();
      *outArg = test_VariableLengthStruct__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_11))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*_ORBIT_retval).a = CORBA_string_alloc(_ORBIT_tmpvar_11);
	 memcpy((*_ORBIT_retval).a, _ORBIT_curptr,
		sizeof((*_ORBIT_retval).a[_ORBIT_tmpvar_10]) *
		_ORBIT_tmpvar_11);
	 _ORBIT_curptr +=
	    sizeof((*_ORBIT_retval).a[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_13))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*inoutArg).a = CORBA_string_alloc(_ORBIT_tmpvar_13);
	 memcpy((*inoutArg).a, _ORBIT_curptr,
		sizeof((*inoutArg).a[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13);
	 _ORBIT_curptr +=
	    sizeof((*inoutArg).a[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_15))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 ((**outArg)).a = CORBA_string_alloc(_ORBIT_tmpvar_15);
	 memcpy(((**outArg)).a, _ORBIT_curptr,
		sizeof(((**outArg)).a[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15);
	 _ORBIT_curptr +=
	    sizeof(((**outArg)).a[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15;
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_11 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*_ORBIT_retval).a = CORBA_string_alloc(_ORBIT_tmpvar_11);
	 memcpy((*_ORBIT_retval).a, _ORBIT_curptr,
		sizeof((*_ORBIT_retval).a[_ORBIT_tmpvar_10]) *
		_ORBIT_tmpvar_11);
	 _ORBIT_curptr +=
	    sizeof((*_ORBIT_retval).a[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_13 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*inoutArg).a = CORBA_string_alloc(_ORBIT_tmpvar_13);
	 memcpy((*inoutArg).a, _ORBIT_curptr,
		sizeof((*inoutArg).a[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13);
	 _ORBIT_curptr +=
	    sizeof((*inoutArg).a[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_15 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 ((**outArg)).a = CORBA_string_alloc(_ORBIT_tmpvar_15);
	 memcpy(((**outArg)).a, _ORBIT_curptr,
		sizeof(((**outArg)).a[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15);
	 _ORBIT_curptr +=
	    sizeof(((**outArg)).a[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_CompoundStruct *
test_StructServer_opCompound(test_StructServer _obj,
			     const test_CompoundStruct * inArg,
			     test_CompoundStruct * inoutArg,
			     test_CompoundStruct ** outArg,
			     CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_CompoundStruct *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_10;
   CORBA_unsigned_long _ORBIT_tmpvar_11;
   register CORBA_unsigned_long _ORBIT_tmpvar_12;
   CORBA_unsigned_long _ORBIT_tmpvar_13;
   register CORBA_unsigned_long _ORBIT_tmpvar_14;
   CORBA_unsigned_long _ORBIT_tmpvar_15;

   if (_obj->servant && _obj->vepv && test_StructServer__classid) {
      _ORBIT_retval =
	 ((POA_test_StructServer__epv *) _obj->
	  vepv[test_StructServer__classid])->opCompound(_obj->servant, inArg,
							inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[11];
      }
      _ORBIT_operation_name_data =
      {
      11, "opCompound"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 15 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      CORBA_unsigned_long _ORBIT_tmpvar_1;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_tmpvar_1 = strlen((*inArg).a.a) + 1;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof(_ORBIT_tmpvar_1));
      }
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     ((*inArg).a.a),
				     sizeof((*inArg).a.a[_ORBIT_tmpvar_0]) *
				     _ORBIT_tmpvar_1);
      _ORBIT_tmpvar_3 = strlen((*inoutArg).a.a) + 1;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_3));
	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_3), sizeof(_ORBIT_tmpvar_3));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof(_ORBIT_tmpvar_3));
      }
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     ((*inoutArg).a.a),
				     sizeof((*inoutArg).a.
					    a[_ORBIT_tmpvar_2]) *
				     _ORBIT_tmpvar_3);
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   test_CompoundStruct__free(inoutArg, NULL, CORBA_TRUE);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = test_CompoundStruct__alloc();
      *outArg = test_CompoundStruct__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_11))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*_ORBIT_retval).a.a = CORBA_string_alloc(_ORBIT_tmpvar_11);
	 memcpy((*_ORBIT_retval).a.a, _ORBIT_curptr,
		sizeof((*_ORBIT_retval).a.a[_ORBIT_tmpvar_10]) *
		_ORBIT_tmpvar_11);
	 _ORBIT_curptr +=
	    sizeof((*_ORBIT_retval).a.a[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_13))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*inoutArg).a.a = CORBA_string_alloc(_ORBIT_tmpvar_13);
	 memcpy((*inoutArg).a.a, _ORBIT_curptr,
		sizeof((*inoutArg).a.a[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13);
	 _ORBIT_curptr +=
	    sizeof((*inoutArg).a.a[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_15))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 ((**outArg)).a.a = CORBA_string_alloc(_ORBIT_tmpvar_15);
	 memcpy(((**outArg)).a.a, _ORBIT_curptr,
		sizeof(((**outArg)).a.a[_ORBIT_tmpvar_14]) *
		_ORBIT_tmpvar_15);
	 _ORBIT_curptr +=
	    sizeof(((**outArg)).a.a[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15;
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_11 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*_ORBIT_retval).a.a = CORBA_string_alloc(_ORBIT_tmpvar_11);
	 memcpy((*_ORBIT_retval).a.a, _ORBIT_curptr,
		sizeof((*_ORBIT_retval).a.a[_ORBIT_tmpvar_10]) *
		_ORBIT_tmpvar_11);
	 _ORBIT_curptr +=
	    sizeof((*_ORBIT_retval).a.a[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_13 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*inoutArg).a.a = CORBA_string_alloc(_ORBIT_tmpvar_13);
	 memcpy((*inoutArg).a.a, _ORBIT_curptr,
		sizeof((*inoutArg).a.a[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13);
	 _ORBIT_curptr +=
	    sizeof((*inoutArg).a.a[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_15 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 ((**outArg)).a.a = CORBA_string_alloc(_ORBIT_tmpvar_15);
	 memcpy(((**outArg)).a.a, _ORBIT_curptr,
		sizeof(((**outArg)).a.a[_ORBIT_tmpvar_14]) *
		_ORBIT_tmpvar_15);
	 _ORBIT_curptr +=
	    sizeof(((**outArg)).a.a[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_StrSeq *
test_SequenceServer_opStrSeq(test_SequenceServer _obj,
			     const test_StrSeq * inArg,
			     test_StrSeq * inoutArg, test_StrSeq ** outArg,
			     CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_StrSeq *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_15;
   register CORBA_unsigned_long _ORBIT_tmpvar_16;
   CORBA_unsigned_long _ORBIT_tmpvar_17;
   register CORBA_unsigned_long _ORBIT_tmpvar_18;
   register CORBA_unsigned_long _ORBIT_tmpvar_19;
   CORBA_unsigned_long _ORBIT_tmpvar_20;
   register CORBA_unsigned_long _ORBIT_tmpvar_21;
   register CORBA_unsigned_long _ORBIT_tmpvar_22;
   CORBA_unsigned_long _ORBIT_tmpvar_23;

   if (_obj->servant && _obj->vepv && test_SequenceServer__classid) {
      _ORBIT_retval =
	 ((POA_test_SequenceServer__epv *) _obj->
	  vepv[test_SequenceServer__classid])->opStrSeq(_obj->servant, inArg,
							inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[9];
      }
      _ORBIT_operation_name_data =
      {
      9, "opStrSeq"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 13 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      register CORBA_unsigned_long _ORBIT_tmpvar_1;
      CORBA_unsigned_long _ORBIT_tmpvar_2;
      register CORBA_unsigned_long _ORBIT_tmpvar_3;
      register CORBA_unsigned_long _ORBIT_tmpvar_4;
      CORBA_unsigned_long _ORBIT_tmpvar_5;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof((*inArg)._length));
	 memcpy(_ORBIT_t, &((*inArg)._length), sizeof((*inArg)._length));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof((*inArg)._length));
      }
      for (_ORBIT_tmpvar_0 = 0; _ORBIT_tmpvar_0 < (*inArg)._length;
	   _ORBIT_tmpvar_0++) {
	 _ORBIT_tmpvar_2 = strlen((*inArg)._buffer[_ORBIT_tmpvar_0]) + 1;
	 giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer), 4);
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_2));
	    memcpy(_ORBIT_t, &(_ORBIT_tmpvar_2), sizeof(_ORBIT_tmpvar_2));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof(_ORBIT_tmpvar_2));
	 }
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t =
	       alloca(sizeof
		      ((*inArg)._buffer[_ORBIT_tmpvar_0][_ORBIT_tmpvar_1]) *
		      _ORBIT_tmpvar_2);
	    memcpy(_ORBIT_t, ((*inArg)._buffer[_ORBIT_tmpvar_0]),
		   sizeof((*inArg).
			  _buffer[_ORBIT_tmpvar_0][_ORBIT_tmpvar_1]) *
		   _ORBIT_tmpvar_2);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof((*inArg).
						  _buffer[_ORBIT_tmpvar_0]
						  [_ORBIT_tmpvar_1]) *
					   _ORBIT_tmpvar_2);
	 }
      }

      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof((*inoutArg)._length));
	 memcpy(_ORBIT_t, &((*inoutArg)._length),
		sizeof((*inoutArg)._length));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof((*inoutArg)._length));
      }
      for (_ORBIT_tmpvar_3 = 0; _ORBIT_tmpvar_3 < (*inoutArg)._length;
	   _ORBIT_tmpvar_3++) {
	 _ORBIT_tmpvar_5 = strlen((*inoutArg)._buffer[_ORBIT_tmpvar_3]) + 1;
	 giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer), 4);
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_5));
	    memcpy(_ORBIT_t, &(_ORBIT_tmpvar_5), sizeof(_ORBIT_tmpvar_5));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof(_ORBIT_tmpvar_5));
	 }
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t =
	       alloca(sizeof
		      ((*inoutArg).
		       _buffer[_ORBIT_tmpvar_3][_ORBIT_tmpvar_4]) *
		      _ORBIT_tmpvar_5);
	    memcpy(_ORBIT_t, ((*inoutArg)._buffer[_ORBIT_tmpvar_3]),
		   sizeof((*inoutArg).
			  _buffer[_ORBIT_tmpvar_3][_ORBIT_tmpvar_4]) *
		   _ORBIT_tmpvar_5);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof((*inoutArg).
						  _buffer[_ORBIT_tmpvar_3]
						  [_ORBIT_tmpvar_4]) *
					   _ORBIT_tmpvar_5);
	 }
      }

      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   if ((*inoutArg)._release)
      CORBA_free((*inoutArg)._buffer);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = test_StrSeq__alloc();
      *outArg = test_StrSeq__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & ((*_ORBIT_retval)._length))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*_ORBIT_retval)._maximum = (*_ORBIT_retval)._length;
	 (*_ORBIT_retval)._buffer =
	    CORBA_sequence_CORBA_string_allocbuf((*_ORBIT_retval)._length);
	 (*_ORBIT_retval)._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_15 = 0;
	      _ORBIT_tmpvar_15 < (*_ORBIT_retval)._length;
	      _ORBIT_tmpvar_15++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_17))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    (*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15] =
	       CORBA_string_alloc(_ORBIT_tmpvar_17);
	    memcpy((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15], _ORBIT_curptr,
		   sizeof((*_ORBIT_retval).
			  _buffer[_ORBIT_tmpvar_15][_ORBIT_tmpvar_16]) *
		   _ORBIT_tmpvar_17);
	    _ORBIT_curptr +=
	       sizeof((*_ORBIT_retval).
		      _buffer[_ORBIT_tmpvar_15][_ORBIT_tmpvar_16]) *
	       _ORBIT_tmpvar_17;
	 }

	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & ((*inoutArg)._length))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*inoutArg)._maximum = (*inoutArg)._length;
	 (*inoutArg)._buffer =
	    CORBA_sequence_CORBA_string_allocbuf((*inoutArg)._length);
	 (*inoutArg)._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_18 = 0; _ORBIT_tmpvar_18 < (*inoutArg)._length;
	      _ORBIT_tmpvar_18++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_20))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    (*inoutArg)._buffer[_ORBIT_tmpvar_18] =
	       CORBA_string_alloc(_ORBIT_tmpvar_20);
	    memcpy((*inoutArg)._buffer[_ORBIT_tmpvar_18], _ORBIT_curptr,
		   sizeof((*inoutArg).
			  _buffer[_ORBIT_tmpvar_18][_ORBIT_tmpvar_19]) *
		   _ORBIT_tmpvar_20);
	    _ORBIT_curptr +=
	       sizeof((*inoutArg).
		      _buffer[_ORBIT_tmpvar_18][_ORBIT_tmpvar_19]) *
	       _ORBIT_tmpvar_20;
	 }

	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (((**outArg))._length))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 ((**outArg))._maximum = ((**outArg))._length;
	 ((**outArg))._buffer =
	    CORBA_sequence_CORBA_string_allocbuf(((**outArg))._length);
	 ((**outArg))._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_21 = 0; _ORBIT_tmpvar_21 < ((**outArg))._length;
	      _ORBIT_tmpvar_21++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_23))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    ((**outArg))._buffer[_ORBIT_tmpvar_21] =
	       CORBA_string_alloc(_ORBIT_tmpvar_23);
	    memcpy(((**outArg))._buffer[_ORBIT_tmpvar_21], _ORBIT_curptr,
		   sizeof(((**outArg)).
			  _buffer[_ORBIT_tmpvar_21][_ORBIT_tmpvar_22]) *
		   _ORBIT_tmpvar_23);
	    _ORBIT_curptr +=
	       sizeof(((**outArg)).
		      _buffer[_ORBIT_tmpvar_21][_ORBIT_tmpvar_22]) *
	       _ORBIT_tmpvar_23;
	 }

      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*_ORBIT_retval)._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*_ORBIT_retval)._maximum = (*_ORBIT_retval)._length;
	 (*_ORBIT_retval)._buffer =
	    CORBA_sequence_CORBA_string_allocbuf((*_ORBIT_retval)._length);
	 (*_ORBIT_retval)._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_15 = 0;
	      _ORBIT_tmpvar_15 < (*_ORBIT_retval)._length;
	      _ORBIT_tmpvar_15++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_17 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    (*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15] =
	       CORBA_string_alloc(_ORBIT_tmpvar_17);
	    memcpy((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15], _ORBIT_curptr,
		   sizeof((*_ORBIT_retval).
			  _buffer[_ORBIT_tmpvar_15][_ORBIT_tmpvar_16]) *
		   _ORBIT_tmpvar_17);
	    _ORBIT_curptr +=
	       sizeof((*_ORBIT_retval).
		      _buffer[_ORBIT_tmpvar_15][_ORBIT_tmpvar_16]) *
	       _ORBIT_tmpvar_17;
	 }

	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*inoutArg)._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*inoutArg)._maximum = (*inoutArg)._length;
	 (*inoutArg)._buffer =
	    CORBA_sequence_CORBA_string_allocbuf((*inoutArg)._length);
	 (*inoutArg)._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_18 = 0; _ORBIT_tmpvar_18 < (*inoutArg)._length;
	      _ORBIT_tmpvar_18++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_20 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    (*inoutArg)._buffer[_ORBIT_tmpvar_18] =
	       CORBA_string_alloc(_ORBIT_tmpvar_20);
	    memcpy((*inoutArg)._buffer[_ORBIT_tmpvar_18], _ORBIT_curptr,
		   sizeof((*inoutArg).
			  _buffer[_ORBIT_tmpvar_18][_ORBIT_tmpvar_19]) *
		   _ORBIT_tmpvar_20);
	    _ORBIT_curptr +=
	       sizeof((*inoutArg).
		      _buffer[_ORBIT_tmpvar_18][_ORBIT_tmpvar_19]) *
	       _ORBIT_tmpvar_20;
	 }

	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 ((**outArg))._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 ((**outArg))._maximum = ((**outArg))._length;
	 ((**outArg))._buffer =
	    CORBA_sequence_CORBA_string_allocbuf(((**outArg))._length);
	 ((**outArg))._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_21 = 0; _ORBIT_tmpvar_21 < ((**outArg))._length;
	      _ORBIT_tmpvar_21++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_23 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    ((**outArg))._buffer[_ORBIT_tmpvar_21] =
	       CORBA_string_alloc(_ORBIT_tmpvar_23);
	    memcpy(((**outArg))._buffer[_ORBIT_tmpvar_21], _ORBIT_curptr,
		   sizeof(((**outArg)).
			  _buffer[_ORBIT_tmpvar_21][_ORBIT_tmpvar_22]) *
		   _ORBIT_tmpvar_23);
	    _ORBIT_curptr +=
	       sizeof(((**outArg)).
		      _buffer[_ORBIT_tmpvar_21][_ORBIT_tmpvar_22]) *
	       _ORBIT_tmpvar_23;
	 }

      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_BoundedStructSeq *
test_SequenceServer_opBoundedStructSeq(test_SequenceServer _obj,
				       const test_BoundedStructSeq * inArg,
				       test_BoundedStructSeq * inoutArg,
				       test_BoundedStructSeq ** outArg,
				       CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_BoundedStructSeq *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_15;
   register CORBA_unsigned_long _ORBIT_tmpvar_16;
   CORBA_unsigned_long _ORBIT_tmpvar_17;
   register CORBA_unsigned_long _ORBIT_tmpvar_18;
   register CORBA_unsigned_long _ORBIT_tmpvar_19;
   CORBA_unsigned_long _ORBIT_tmpvar_20;
   register CORBA_unsigned_long _ORBIT_tmpvar_21;
   register CORBA_unsigned_long _ORBIT_tmpvar_22;
   CORBA_unsigned_long _ORBIT_tmpvar_23;

   if (_obj->servant && _obj->vepv && test_SequenceServer__classid) {
      _ORBIT_retval =
	 ((POA_test_SequenceServer__epv *) _obj->
	  vepv[test_SequenceServer__classid])->opBoundedStructSeq(_obj->
								  servant,
								  inArg,
								  inoutArg,
								  outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[19];
      }
      _ORBIT_operation_name_data =
      {
      19, "opBoundedStructSeq"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 23 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      register CORBA_unsigned_long _ORBIT_tmpvar_1;
      CORBA_unsigned_long _ORBIT_tmpvar_2;
      register CORBA_unsigned_long _ORBIT_tmpvar_3;
      register CORBA_unsigned_long _ORBIT_tmpvar_4;
      CORBA_unsigned_long _ORBIT_tmpvar_5;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof((*inArg)._length));
	 memcpy(_ORBIT_t, &((*inArg)._length), sizeof((*inArg)._length));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof((*inArg)._length));
      }
      for (_ORBIT_tmpvar_0 = 0; _ORBIT_tmpvar_0 < (*inArg)._length;
	   _ORBIT_tmpvar_0++) {
	 _ORBIT_tmpvar_2 = strlen((*inArg)._buffer[_ORBIT_tmpvar_0].a.a) + 1;
	 giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer), 4);
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_2));
	    memcpy(_ORBIT_t, &(_ORBIT_tmpvar_2), sizeof(_ORBIT_tmpvar_2));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof(_ORBIT_tmpvar_2));
	 }
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t =
	       alloca(sizeof
		      ((*inArg)._buffer[_ORBIT_tmpvar_0].a.
		       a[_ORBIT_tmpvar_1]) * _ORBIT_tmpvar_2);
	    memcpy(_ORBIT_t, ((*inArg)._buffer[_ORBIT_tmpvar_0].a.a),
		   sizeof((*inArg)._buffer[_ORBIT_tmpvar_0].a.
			  a[_ORBIT_tmpvar_1]) * _ORBIT_tmpvar_2);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof((*inArg).
						  _buffer[_ORBIT_tmpvar_0].a.
						  a[_ORBIT_tmpvar_1]) *
					   _ORBIT_tmpvar_2);
	 }
      }

      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof((*inoutArg)._length));
	 memcpy(_ORBIT_t, &((*inoutArg)._length),
		sizeof((*inoutArg)._length));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof((*inoutArg)._length));
      }
      for (_ORBIT_tmpvar_3 = 0; _ORBIT_tmpvar_3 < (*inoutArg)._length;
	   _ORBIT_tmpvar_3++) {
	 _ORBIT_tmpvar_5 =
	    strlen((*inoutArg)._buffer[_ORBIT_tmpvar_3].a.a) + 1;
	 giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer), 4);
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_5));
	    memcpy(_ORBIT_t, &(_ORBIT_tmpvar_5), sizeof(_ORBIT_tmpvar_5));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof(_ORBIT_tmpvar_5));
	 }
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t =
	       alloca(sizeof
		      ((*inoutArg)._buffer[_ORBIT_tmpvar_3].a.
		       a[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5);
	    memcpy(_ORBIT_t, ((*inoutArg)._buffer[_ORBIT_tmpvar_3].a.a),
		   sizeof((*inoutArg)._buffer[_ORBIT_tmpvar_3].a.
			  a[_ORBIT_tmpvar_4]) * _ORBIT_tmpvar_5);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof((*inoutArg).
						  _buffer[_ORBIT_tmpvar_3].a.
						  a[_ORBIT_tmpvar_4]) *
					   _ORBIT_tmpvar_5);
	 }
      }

      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   if ((*inoutArg)._release)
      CORBA_free((*inoutArg)._buffer);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = test_BoundedStructSeq__alloc();
      *outArg = test_BoundedStructSeq__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & ((*_ORBIT_retval)._length))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*_ORBIT_retval)._maximum = 2;
	 (*_ORBIT_retval)._buffer =
	    CORBA_sequence_test_CompoundStruct_allocbuf((*_ORBIT_retval).
							_maximum);
	 (*_ORBIT_retval)._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_15 = 0;
	      _ORBIT_tmpvar_15 < (*_ORBIT_retval)._length;
	      _ORBIT_tmpvar_15++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_17))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    (*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15].a.a =
	       CORBA_string_alloc(_ORBIT_tmpvar_17);
	    memcpy((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15].a.a,
		   _ORBIT_curptr,
		   sizeof((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15].a.
			  a[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17);
	    _ORBIT_curptr +=
	       sizeof((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15].a.
		      a[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17;
	 }

	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & ((*inoutArg)._length))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*inoutArg)._maximum = 2;
	 (*inoutArg)._buffer =
	    CORBA_sequence_test_CompoundStruct_allocbuf((*inoutArg)._maximum);
	 (*inoutArg)._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_18 = 0; _ORBIT_tmpvar_18 < (*inoutArg)._length;
	      _ORBIT_tmpvar_18++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_20))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    (*inoutArg)._buffer[_ORBIT_tmpvar_18].a.a =
	       CORBA_string_alloc(_ORBIT_tmpvar_20);
	    memcpy((*inoutArg)._buffer[_ORBIT_tmpvar_18].a.a, _ORBIT_curptr,
		   sizeof((*inoutArg)._buffer[_ORBIT_tmpvar_18].a.
			  a[_ORBIT_tmpvar_19]) * _ORBIT_tmpvar_20);
	    _ORBIT_curptr +=
	       sizeof((*inoutArg)._buffer[_ORBIT_tmpvar_18].a.
		      a[_ORBIT_tmpvar_19]) * _ORBIT_tmpvar_20;
	 }

	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (((**outArg))._length))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 ((**outArg))._maximum = 2;
	 ((**outArg))._buffer =
	    CORBA_sequence_test_CompoundStruct_allocbuf(((**outArg)).
							_maximum);
	 ((**outArg))._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_21 = 0; _ORBIT_tmpvar_21 < ((**outArg))._length;
	      _ORBIT_tmpvar_21++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_23))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    ((**outArg))._buffer[_ORBIT_tmpvar_21].a.a =
	       CORBA_string_alloc(_ORBIT_tmpvar_23);
	    memcpy(((**outArg))._buffer[_ORBIT_tmpvar_21].a.a, _ORBIT_curptr,
		   sizeof(((**outArg))._buffer[_ORBIT_tmpvar_21].a.
			  a[_ORBIT_tmpvar_22]) * _ORBIT_tmpvar_23);
	    _ORBIT_curptr +=
	       sizeof(((**outArg))._buffer[_ORBIT_tmpvar_21].a.
		      a[_ORBIT_tmpvar_22]) * _ORBIT_tmpvar_23;
	 }

      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*_ORBIT_retval)._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*_ORBIT_retval)._maximum = 2;
	 (*_ORBIT_retval)._buffer =
	    CORBA_sequence_test_CompoundStruct_allocbuf((*_ORBIT_retval).
							_maximum);
	 (*_ORBIT_retval)._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_15 = 0;
	      _ORBIT_tmpvar_15 < (*_ORBIT_retval)._length;
	      _ORBIT_tmpvar_15++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_17 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    (*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15].a.a =
	       CORBA_string_alloc(_ORBIT_tmpvar_17);
	    memcpy((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15].a.a,
		   _ORBIT_curptr,
		   sizeof((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15].a.
			  a[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17);
	    _ORBIT_curptr +=
	       sizeof((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_15].a.
		      a[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17;
	 }

	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*inoutArg)._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*inoutArg)._maximum = 2;
	 (*inoutArg)._buffer =
	    CORBA_sequence_test_CompoundStruct_allocbuf((*inoutArg)._maximum);
	 (*inoutArg)._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_18 = 0; _ORBIT_tmpvar_18 < (*inoutArg)._length;
	      _ORBIT_tmpvar_18++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_20 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    (*inoutArg)._buffer[_ORBIT_tmpvar_18].a.a =
	       CORBA_string_alloc(_ORBIT_tmpvar_20);
	    memcpy((*inoutArg)._buffer[_ORBIT_tmpvar_18].a.a, _ORBIT_curptr,
		   sizeof((*inoutArg)._buffer[_ORBIT_tmpvar_18].a.
			  a[_ORBIT_tmpvar_19]) * _ORBIT_tmpvar_20);
	    _ORBIT_curptr +=
	       sizeof((*inoutArg)._buffer[_ORBIT_tmpvar_18].a.
		      a[_ORBIT_tmpvar_19]) * _ORBIT_tmpvar_20;
	 }

	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 ((**outArg))._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 ((**outArg))._maximum = 2;
	 ((**outArg))._buffer =
	    CORBA_sequence_test_CompoundStruct_allocbuf(((**outArg)).
							_maximum);
	 ((**outArg))._release = CORBA_TRUE;
	 for (_ORBIT_tmpvar_21 = 0; _ORBIT_tmpvar_21 < ((**outArg))._length;
	      _ORBIT_tmpvar_21++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_23 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    ((**outArg))._buffer[_ORBIT_tmpvar_21].a.a =
	       CORBA_string_alloc(_ORBIT_tmpvar_23);
	    memcpy(((**outArg))._buffer[_ORBIT_tmpvar_21].a.a, _ORBIT_curptr,
		   sizeof(((**outArg))._buffer[_ORBIT_tmpvar_21].a.
			  a[_ORBIT_tmpvar_22]) * _ORBIT_tmpvar_23);
	    _ORBIT_curptr +=
	       sizeof(((**outArg))._buffer[_ORBIT_tmpvar_21].a.
		      a[_ORBIT_tmpvar_22]) * _ORBIT_tmpvar_23;
	 }

      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
void
_ORBIT_test_TestException_demarshal(GIOPRecvBuffer * _ORBIT_recv_buffer,
				    CORBA_Environment * ev)
{
   guchar *_ORBIT_curptr;
   register CORBA_unsigned_long _ORBIT_tmpvar_0;
   CORBA_unsigned_long _ORBIT_tmpvar_1;
   register CORBA_unsigned_long _ORBIT_tmpvar_2;
   test_TestException *_ORBIT_exdata = test_TestException__alloc();

   _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
   if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
      (*((guint32 *) & (_ORBIT_tmpvar_1))) =
	 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      _ORBIT_curptr += 4;
      (*_ORBIT_exdata).reason = CORBA_string_alloc(_ORBIT_tmpvar_1);
      memcpy((*_ORBIT_exdata).reason, _ORBIT_curptr,
	     sizeof((*_ORBIT_exdata).reason[_ORBIT_tmpvar_0]) *
	     _ORBIT_tmpvar_1);
      _ORBIT_curptr +=
	 sizeof((*_ORBIT_exdata).reason[_ORBIT_tmpvar_0]) * _ORBIT_tmpvar_1;
      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
      (*((guint32 *) & ((*_ORBIT_exdata).number))) =
	 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      _ORBIT_curptr += 4;
      (*((guint32 *) & ((*_ORBIT_exdata).aseq._length))) =
	 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      _ORBIT_curptr += 4;
      (*_ORBIT_exdata).aseq._maximum = (*_ORBIT_exdata).aseq._length;
      (*_ORBIT_exdata).aseq._buffer =
	 CORBA_sequence_CORBA_long_allocbuf((*_ORBIT_exdata).aseq._length);
      (*_ORBIT_exdata).aseq._release = CORBA_TRUE;
      for (_ORBIT_tmpvar_2 = 0;
	   _ORBIT_tmpvar_2 < (*_ORBIT_exdata).aseq._length;
	   _ORBIT_tmpvar_2++) {
	 (*((guint32 *) & ((*_ORBIT_exdata).aseq._buffer[_ORBIT_tmpvar_2]))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
      }

      GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
      (*_ORBIT_exdata).factory =
	 ORBit_demarshal_object(_ORBIT_recv_buffer,
				GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				connection->orb_data);
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
   } else {
      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
      _ORBIT_tmpvar_1 = *((CORBA_unsigned_long *) _ORBIT_curptr);
      _ORBIT_curptr += 4;
      (*_ORBIT_exdata).reason = CORBA_string_alloc(_ORBIT_tmpvar_1);
      memcpy((*_ORBIT_exdata).reason, _ORBIT_curptr,
	     sizeof((*_ORBIT_exdata).reason[_ORBIT_tmpvar_0]) *
	     _ORBIT_tmpvar_1);
      _ORBIT_curptr +=
	 sizeof((*_ORBIT_exdata).reason[_ORBIT_tmpvar_0]) * _ORBIT_tmpvar_1;
      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
      (*_ORBIT_exdata).number = *((CORBA_long *) _ORBIT_curptr);
      _ORBIT_curptr += 4;
      (*_ORBIT_exdata).aseq._length =
	 *((CORBA_unsigned_long *) _ORBIT_curptr);
      _ORBIT_curptr += 4;
      (*_ORBIT_exdata).aseq._maximum = (*_ORBIT_exdata).aseq._length;
      (*_ORBIT_exdata).aseq._buffer =
	 CORBA_sequence_CORBA_long_allocbuf((*_ORBIT_exdata).aseq._length);
      (*_ORBIT_exdata).aseq._release = CORBA_TRUE;
      memcpy((*_ORBIT_exdata).aseq._buffer, _ORBIT_curptr,
	     sizeof((*_ORBIT_exdata).aseq._buffer[_ORBIT_tmpvar_2]) *
	     (*_ORBIT_exdata).aseq._length);
      _ORBIT_curptr +=
	 sizeof((*_ORBIT_exdata).aseq._buffer[_ORBIT_tmpvar_2]) *
	 (*_ORBIT_exdata).aseq._length;
      GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
      (*_ORBIT_exdata).factory =
	 ORBit_demarshal_object(_ORBIT_recv_buffer,
				GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				connection->orb_data);
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
   }
   CORBA_exception_set(ev, CORBA_USER_EXCEPTION,
		       TC_test_TestException_struct.repo_id, _ORBIT_exdata);
}

test_LongArray_slice *
test_ArrayServer_opLongArray(test_ArrayServer _obj,
			     const test_LongArray inArg,
			     test_LongArray inoutArg, test_LongArray outArg,
			     CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_LongArray_slice *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_5;
   register CORBA_unsigned_long _ORBIT_tmpvar_6;
   register CORBA_unsigned_long _ORBIT_tmpvar_7;

   if (_obj->servant && _obj->vepv && test_ArrayServer__classid) {
      _ORBIT_retval =
	 ((POA_test_ArrayServer__epv *) _obj->
	  vepv[test_ArrayServer__classid])->opLongArray(_obj->servant, inArg,
							inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[12];
      }
      _ORBIT_operation_name_data =
      {
      12, "opLongArray"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 16 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      register CORBA_unsigned_long _ORBIT_tmpvar_1;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     (inArg),
				     sizeof(inArg[_ORBIT_tmpvar_0]) * 2);
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     (inoutArg),
				     sizeof(inoutArg[_ORBIT_tmpvar_1]) * 2);
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = test_LongArray__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 for (_ORBIT_tmpvar_5 = 0; _ORBIT_tmpvar_5 < 2; _ORBIT_tmpvar_5++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_retval[_ORBIT_tmpvar_5]))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	 }

	 for (_ORBIT_tmpvar_6 = 0; _ORBIT_tmpvar_6 < 2; _ORBIT_tmpvar_6++) {
	    (*((guint32 *) & (inoutArg[_ORBIT_tmpvar_6]))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	 }

	 for (_ORBIT_tmpvar_7 = 0; _ORBIT_tmpvar_7 < 2; _ORBIT_tmpvar_7++) {
	    (*((guint32 *) & (outArg[_ORBIT_tmpvar_7]))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	 }

      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 memcpy(_ORBIT_retval, _ORBIT_curptr,
		sizeof(_ORBIT_retval[_ORBIT_tmpvar_5]) * 2);
	 _ORBIT_curptr += sizeof(_ORBIT_retval[_ORBIT_tmpvar_5]) * 2;
	 memcpy(inoutArg, _ORBIT_curptr,
		sizeof(inoutArg[_ORBIT_tmpvar_6]) * 2);
	 _ORBIT_curptr += sizeof(inoutArg[_ORBIT_tmpvar_6]) * 2;
	 memcpy(outArg, _ORBIT_curptr, sizeof(outArg[_ORBIT_tmpvar_7]) * 2);
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_StrArray_slice *
test_ArrayServer_opStrArray(test_ArrayServer _obj, const test_StrArray inArg,
			    test_StrArray inoutArg,
			    test_StrArray_slice ** outArg,
			    CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_StrArray_slice *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_15;
   register CORBA_unsigned_long _ORBIT_tmpvar_16;
   CORBA_unsigned_long _ORBIT_tmpvar_17;
   register CORBA_unsigned_long _ORBIT_tmpvar_18;
   register CORBA_unsigned_long _ORBIT_tmpvar_19;
   CORBA_unsigned_long _ORBIT_tmpvar_20;
   register CORBA_unsigned_long _ORBIT_tmpvar_21;
   register CORBA_unsigned_long _ORBIT_tmpvar_22;
   CORBA_unsigned_long _ORBIT_tmpvar_23;

   if (_obj->servant && _obj->vepv && test_ArrayServer__classid) {
      _ORBIT_retval =
	 ((POA_test_ArrayServer__epv *) _obj->
	  vepv[test_ArrayServer__classid])->opStrArray(_obj->servant, inArg,
						       inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[11];
      }
      _ORBIT_operation_name_data =
      {
      11, "opStrArray"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 15 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      register CORBA_unsigned_long _ORBIT_tmpvar_1;
      CORBA_unsigned_long _ORBIT_tmpvar_2;
      register CORBA_unsigned_long _ORBIT_tmpvar_3;
      register CORBA_unsigned_long _ORBIT_tmpvar_4;
      CORBA_unsigned_long _ORBIT_tmpvar_5;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      for (_ORBIT_tmpvar_0 = 0; _ORBIT_tmpvar_0 < 2; _ORBIT_tmpvar_0++) {
	 _ORBIT_tmpvar_2 = strlen(inArg[_ORBIT_tmpvar_0]) + 1;
	 giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer), 4);
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_2));
	    memcpy(_ORBIT_t, &(_ORBIT_tmpvar_2), sizeof(_ORBIT_tmpvar_2));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof(_ORBIT_tmpvar_2));
	 }
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer),
					(inArg[_ORBIT_tmpvar_0]),
					sizeof(inArg[_ORBIT_tmpvar_0]
					       [_ORBIT_tmpvar_1]) *
					_ORBIT_tmpvar_2);
      }

      for (_ORBIT_tmpvar_3 = 0; _ORBIT_tmpvar_3 < 2; _ORBIT_tmpvar_3++) {
	 _ORBIT_tmpvar_5 = strlen(inoutArg[_ORBIT_tmpvar_3]) + 1;
	 giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer), 4);
	 {
	    guchar *_ORBIT_t;

	    _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_5));
	    memcpy(_ORBIT_t, &(_ORBIT_tmpvar_5), sizeof(_ORBIT_tmpvar_5));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (_ORBIT_t),
					   sizeof(_ORBIT_tmpvar_5));
	 }
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer),
					(inoutArg[_ORBIT_tmpvar_3]),
					sizeof(inoutArg[_ORBIT_tmpvar_3]
					       [_ORBIT_tmpvar_4]) *
					_ORBIT_tmpvar_5);
      }

      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   test_StrArray__free(inoutArg, NULL, CORBA_TRUE);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = test_StrArray__alloc();
      *outArg = test_StrArray__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 for (_ORBIT_tmpvar_15 = 0; _ORBIT_tmpvar_15 < 2; _ORBIT_tmpvar_15++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_17))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    _ORBIT_retval[_ORBIT_tmpvar_15] =
	       CORBA_string_alloc(_ORBIT_tmpvar_17);
	    memcpy(_ORBIT_retval[_ORBIT_tmpvar_15], _ORBIT_curptr,
		   sizeof(_ORBIT_retval[_ORBIT_tmpvar_15][_ORBIT_tmpvar_16]) *
		   _ORBIT_tmpvar_17);
	    _ORBIT_curptr +=
	       sizeof(_ORBIT_retval[_ORBIT_tmpvar_15][_ORBIT_tmpvar_16]) *
	       _ORBIT_tmpvar_17;
	 }

	 for (_ORBIT_tmpvar_18 = 0; _ORBIT_tmpvar_18 < 2; _ORBIT_tmpvar_18++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_20))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    inoutArg[_ORBIT_tmpvar_18] = CORBA_string_alloc(_ORBIT_tmpvar_20);
	    memcpy(inoutArg[_ORBIT_tmpvar_18], _ORBIT_curptr,
		   sizeof(inoutArg[_ORBIT_tmpvar_18][_ORBIT_tmpvar_19]) *
		   _ORBIT_tmpvar_20);
	    _ORBIT_curptr +=
	       sizeof(inoutArg[_ORBIT_tmpvar_18][_ORBIT_tmpvar_19]) *
	       _ORBIT_tmpvar_20;
	 }

	 for (_ORBIT_tmpvar_21 = 0; _ORBIT_tmpvar_21 < 2; _ORBIT_tmpvar_21++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_23))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    (*outArg)[_ORBIT_tmpvar_21] =
	       CORBA_string_alloc(_ORBIT_tmpvar_23);
	    memcpy((*outArg)[_ORBIT_tmpvar_21], _ORBIT_curptr,
		   sizeof((*outArg)[_ORBIT_tmpvar_21][_ORBIT_tmpvar_22]) *
		   _ORBIT_tmpvar_23);
	    _ORBIT_curptr +=
	       sizeof((*outArg)[_ORBIT_tmpvar_21][_ORBIT_tmpvar_22]) *
	       _ORBIT_tmpvar_23;
	 }

      } else {
	 for (_ORBIT_tmpvar_15 = 0; _ORBIT_tmpvar_15 < 2; _ORBIT_tmpvar_15++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_17 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    _ORBIT_retval[_ORBIT_tmpvar_15] =
	       CORBA_string_alloc(_ORBIT_tmpvar_17);
	    memcpy(_ORBIT_retval[_ORBIT_tmpvar_15], _ORBIT_curptr,
		   sizeof(_ORBIT_retval[_ORBIT_tmpvar_15][_ORBIT_tmpvar_16]) *
		   _ORBIT_tmpvar_17);
	    _ORBIT_curptr +=
	       sizeof(_ORBIT_retval[_ORBIT_tmpvar_15][_ORBIT_tmpvar_16]) *
	       _ORBIT_tmpvar_17;
	 }

	 for (_ORBIT_tmpvar_18 = 0; _ORBIT_tmpvar_18 < 2; _ORBIT_tmpvar_18++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_20 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    inoutArg[_ORBIT_tmpvar_18] = CORBA_string_alloc(_ORBIT_tmpvar_20);
	    memcpy(inoutArg[_ORBIT_tmpvar_18], _ORBIT_curptr,
		   sizeof(inoutArg[_ORBIT_tmpvar_18][_ORBIT_tmpvar_19]) *
		   _ORBIT_tmpvar_20);
	    _ORBIT_curptr +=
	       sizeof(inoutArg[_ORBIT_tmpvar_18][_ORBIT_tmpvar_19]) *
	       _ORBIT_tmpvar_20;
	 }

	 for (_ORBIT_tmpvar_21 = 0; _ORBIT_tmpvar_21 < 2; _ORBIT_tmpvar_21++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_23 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    (*outArg)[_ORBIT_tmpvar_21] =
	       CORBA_string_alloc(_ORBIT_tmpvar_23);
	    memcpy((*outArg)[_ORBIT_tmpvar_21], _ORBIT_curptr,
		   sizeof((*outArg)[_ORBIT_tmpvar_21][_ORBIT_tmpvar_22]) *
		   _ORBIT_tmpvar_23);
	    _ORBIT_curptr +=
	       sizeof((*outArg)[_ORBIT_tmpvar_21][_ORBIT_tmpvar_22]) *
	       _ORBIT_tmpvar_23;
	 }

      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
CORBA_char *
test_BasicServer__get_foo(test_BasicServer _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_char *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_2;
   CORBA_unsigned_long _ORBIT_tmpvar_3;

   if (_obj->servant && _obj->vepv && test_BasicServer__classid) {
      _ORBIT_retval =
	 ((POA_test_BasicServer__epv *) _obj->
	  vepv[test_BasicServer__classid])->_get_foo(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[9];
      }
      _ORBIT_operation_name_data =
      {
      9, "_get_foo"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 13 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_3))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 _ORBIT_retval = CORBA_string_alloc(_ORBIT_tmpvar_3);
	 memcpy(_ORBIT_retval, _ORBIT_curptr,
		sizeof(_ORBIT_retval[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3);
	 _ORBIT_curptr +=
	    sizeof(_ORBIT_retval[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 _ORBIT_retval = CORBA_string_alloc(_ORBIT_tmpvar_3);
	 memcpy(_ORBIT_retval, _ORBIT_curptr,
		sizeof(_ORBIT_retval[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3);
	 _ORBIT_curptr +=
	    sizeof(_ORBIT_retval[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
void
test_BasicServer__set_foo(test_BasicServer _obj, const CORBA_char * value,
			  CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;

   if (_obj->servant && _obj->vepv && test_BasicServer__classid) {
      ((POA_test_BasicServer__epv *) _obj->vepv[test_BasicServer__classid])->
	 _set_foo(_obj->servant, value, ev);
      return;
   }
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[9];
      }
      _ORBIT_operation_name_data =
      {
      9, "_set_foo"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 13 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      CORBA_unsigned_long _ORBIT_tmpvar_1;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_tmpvar_1 = strlen(value) + 1;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof(_ORBIT_tmpvar_1));
      }
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     (value),
				     sizeof(value[_ORBIT_tmpvar_0]) *
				     _ORBIT_tmpvar_1);
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return;
      }
   }
}
CORBA_long
test_BasicServer__get_bah(test_BasicServer _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_long _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_BasicServer__classid) {
      _ORBIT_retval =
	 ((POA_test_BasicServer__epv *) _obj->
	  vepv[test_BasicServer__classid])->_get_bah(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[9];
      }
      _ORBIT_operation_name_data =
      {
      9, "_get_bah"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 13 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_retval))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_retval = *((CORBA_long *) _ORBIT_curptr);
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
CORBA_char *
test_BasicServer_opString(test_BasicServer _obj, const CORBA_char * inArg,
			  CORBA_char ** inoutArg, CORBA_char ** outArg,
			  CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_char *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_10;
   CORBA_unsigned_long _ORBIT_tmpvar_11;
   register CORBA_unsigned_long _ORBIT_tmpvar_12;
   CORBA_unsigned_long _ORBIT_tmpvar_13;
   register CORBA_unsigned_long _ORBIT_tmpvar_14;
   CORBA_unsigned_long _ORBIT_tmpvar_15;

   if (_obj->servant && _obj->vepv && test_BasicServer__classid) {
      _ORBIT_retval =
	 ((POA_test_BasicServer__epv *) _obj->
	  vepv[test_BasicServer__classid])->opString(_obj->servant, inArg,
						     inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[9];
      }
      _ORBIT_operation_name_data =
      {
      9, "opString"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 13 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      CORBA_unsigned_long _ORBIT_tmpvar_1;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_tmpvar_1 = strlen(inArg) + 1;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof(_ORBIT_tmpvar_1));
      }
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     (inArg),
				     sizeof(inArg[_ORBIT_tmpvar_0]) *
				     _ORBIT_tmpvar_1);
      _ORBIT_tmpvar_3 = strlen((*inoutArg)) + 1;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_3));
	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_3), sizeof(_ORBIT_tmpvar_3));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof(_ORBIT_tmpvar_3));
      }
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     ((*inoutArg)),
				     sizeof((*inoutArg)[_ORBIT_tmpvar_2]) *
				     _ORBIT_tmpvar_3);
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   CORBA_free(*inoutArg);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_11))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 _ORBIT_retval = CORBA_string_alloc(_ORBIT_tmpvar_11);
	 memcpy(_ORBIT_retval, _ORBIT_curptr,
		sizeof(_ORBIT_retval[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11);
	 _ORBIT_curptr +=
	    sizeof(_ORBIT_retval[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_13))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*inoutArg) = CORBA_string_alloc(_ORBIT_tmpvar_13);
	 memcpy((*inoutArg), _ORBIT_curptr,
		sizeof((*inoutArg)[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13);
	 _ORBIT_curptr +=
	    sizeof((*inoutArg)[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_15))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*outArg) = CORBA_string_alloc(_ORBIT_tmpvar_15);
	 memcpy((*outArg), _ORBIT_curptr,
		sizeof((*outArg)[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15);
	 _ORBIT_curptr +=
	    sizeof((*outArg)[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15;
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_11 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 _ORBIT_retval = CORBA_string_alloc(_ORBIT_tmpvar_11);
	 memcpy(_ORBIT_retval, _ORBIT_curptr,
		sizeof(_ORBIT_retval[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11);
	 _ORBIT_curptr +=
	    sizeof(_ORBIT_retval[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_13 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*inoutArg) = CORBA_string_alloc(_ORBIT_tmpvar_13);
	 memcpy((*inoutArg), _ORBIT_curptr,
		sizeof((*inoutArg)[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13);
	 _ORBIT_curptr +=
	    sizeof((*inoutArg)[_ORBIT_tmpvar_12]) * _ORBIT_tmpvar_13;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_15 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*outArg) = CORBA_string_alloc(_ORBIT_tmpvar_15);
	 memcpy((*outArg), _ORBIT_curptr,
		sizeof((*outArg)[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15);
	 _ORBIT_curptr +=
	    sizeof((*outArg)[_ORBIT_tmpvar_14]) * _ORBIT_tmpvar_15;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
CORBA_long
test_BasicServer_opLong(test_BasicServer _obj, const CORBA_long inArg,
			CORBA_long * inoutArg, CORBA_long * outArg,
			CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_long _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_BasicServer__classid) {
      _ORBIT_retval =
	 ((POA_test_BasicServer__epv *) _obj->
	  vepv[test_BasicServer__classid])->opLong(_obj->servant, inArg,
						   inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[7];
      }
      _ORBIT_operation_name_data =
      {
      7, "opLong"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 11 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &(inArg), sizeof(inArg));
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &((*inoutArg)), sizeof((*inoutArg)));
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_retval))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & ((*inoutArg)))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & ((*outArg)))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_retval = *((CORBA_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*inoutArg) = *((CORBA_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*outArg) = *((CORBA_long *) _ORBIT_curptr);
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_AnEnum
test_BasicServer_opEnum(test_BasicServer _obj, const test_AnEnum inArg,
			test_AnEnum * inoutArg, test_AnEnum * outArg,
			CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_AnEnum _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_BasicServer__classid) {
      _ORBIT_retval =
	 ((POA_test_BasicServer__epv *) _obj->
	  vepv[test_BasicServer__classid])->opEnum(_obj->servant, inArg,
						   inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[7];
      }
      _ORBIT_operation_name_data =
      {
      7, "opEnum"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 11 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &(inArg), sizeof(inArg));
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &((*inoutArg)), sizeof((*inoutArg)));
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_retval))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & ((*inoutArg)))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & ((*outArg)))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_retval = *((test_AnEnum *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*inoutArg) = *((test_AnEnum *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 (*outArg) = *((test_AnEnum *) _ORBIT_curptr);
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
void
test_BasicServer_opException(test_BasicServer _obj, CORBA_Environment * ev)
{
   static const ORBit_exception_demarshal_info _ORBIT_user_exceptions[] =
      { {(const CORBA_TypeCode) &TC_test_TestException_struct,
	 (gpointer) _ORBIT_test_TestException_demarshal}, {CORBA_OBJECT_NIL,
							   NULL} };
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;

   if (_obj->servant && _obj->vepv && test_BasicServer__classid) {
      ((POA_test_BasicServer__epv *) _obj->vepv[test_BasicServer__classid])->
	 opException(_obj->servant, ev);
      return;
   }
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[12];
      }
      _ORBIT_operation_name_data =
      {
      12, "opException"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 16 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev,
				_ORBIT_user_exceptions, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return;
      }
   }
}
CORBA_long
test_BaseServer_opPolymorphic(test_BaseServer _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_long _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_BaseServer__classid) {
      _ORBIT_retval =
	 ((POA_test_BaseServer__epv *) _obj->vepv[test_BaseServer__classid])->
	 opPolymorphic(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[14];
      }
      _ORBIT_operation_name_data =
      {
      14, "opPolymorphic"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 18 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_retval))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_retval = *((CORBA_long *) _ORBIT_curptr);
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
CORBA_char *
test_BaseServer__get_attribPolymorphic(test_BaseServer _obj,
				       CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_char *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_2;
   CORBA_unsigned_long _ORBIT_tmpvar_3;

   if (_obj->servant && _obj->vepv && test_BaseServer__classid) {
      _ORBIT_retval =
	 ((POA_test_BaseServer__epv *) _obj->vepv[test_BaseServer__classid])->
	 _get_attribPolymorphic(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[23];
      }
      _ORBIT_operation_name_data =
      {
      23, "_get_attribPolymorphic"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 27 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_3))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 _ORBIT_retval = CORBA_string_alloc(_ORBIT_tmpvar_3);
	 memcpy(_ORBIT_retval, _ORBIT_curptr,
		sizeof(_ORBIT_retval[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3);
	 _ORBIT_curptr +=
	    sizeof(_ORBIT_retval[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_3 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 _ORBIT_retval = CORBA_string_alloc(_ORBIT_tmpvar_3);
	 memcpy(_ORBIT_retval, _ORBIT_curptr,
		sizeof(_ORBIT_retval[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3);
	 _ORBIT_curptr +=
	    sizeof(_ORBIT_retval[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
void
test_BaseServer__set_attribPolymorphic(test_BaseServer _obj,
				       const CORBA_char * value,
				       CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;

   if (_obj->servant && _obj->vepv && test_BaseServer__classid) {
      ((POA_test_BaseServer__epv *) _obj->vepv[test_BaseServer__classid])->
	 _set_attribPolymorphic(_obj->servant, value, ev);
      return;
   }
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[23];
      }
      _ORBIT_operation_name_data =
      {
      23, "_set_attribPolymorphic"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 27 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      CORBA_unsigned_long _ORBIT_tmpvar_1;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_tmpvar_1 = strlen(value) + 1;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      {
	 guchar *_ORBIT_t;

	 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
	 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
	 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					(_ORBIT_send_buffer), (_ORBIT_t),
					sizeof(_ORBIT_tmpvar_1));
      }
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     (value),
				     sizeof(value[_ORBIT_tmpvar_0]) *
				     _ORBIT_tmpvar_1);
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
      } else {
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return;
      }
   }
}
test_FixedLengthUnion
test_UnionServer_opFixed(test_UnionServer _obj,
			 const test_FixedLengthUnion * inArg,
			 test_FixedLengthUnion * inoutArg,
			 test_FixedLengthUnion * outArg,
			 CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_FixedLengthUnion _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_UnionServer__classid) {
      _ORBIT_retval =
	 ((POA_test_UnionServer__epv *) _obj->
	  vepv[test_UnionServer__classid])->opFixed(_obj->servant, inArg,
						    inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[8];
      }
      _ORBIT_operation_name_data =
      {
      8, "opFixed"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 12 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &((*inArg)._d), sizeof((*inArg)._d));
      switch ((*inArg)._d) {
	case 'a':
	   giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					    (_ORBIT_send_buffer), 4);
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inArg)._u.x),
					  sizeof((*inArg)._u.x));
	   break;
	case 'b':
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inArg)._u.y),
					  sizeof((*inArg)._u.y));
	   break;
	case 'c':
	case 'd':
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inArg)._u.z),
					  sizeof((*inArg)._u.z));
	   break;
	case 'e':
	   giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					    (_ORBIT_send_buffer), 2);
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inArg)._u.v),
					  sizeof((*inArg)._u.v));
	   break;
	default:
	   break;
      }
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &((*inoutArg)._d),
				     sizeof((*inoutArg)._d));
      switch ((*inoutArg)._d) {
	case 'a':
	   giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					    (_ORBIT_send_buffer), 4);
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inoutArg)._u.x),
					  sizeof((*inoutArg)._u.x));
	   break;
	case 'b':
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inoutArg)._u.y),
					  sizeof((*inoutArg)._u.y));
	   break;
	case 'c':
	case 'd':
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inoutArg)._u.z),
					  sizeof((*inoutArg)._u.z));
	   break;
	case 'e':
	   giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					    (_ORBIT_send_buffer), 2);
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inoutArg)._u.v),
					  sizeof((*inoutArg)._u.v));
	   break;
	default:
	   break;
      }
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_retval._d = *((CORBA_char *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 switch (_ORBIT_retval._d) {
	   case 'a':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	      (*((guint32 *) & (_ORBIT_retval._u.x))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      break;
	   case 'b':
	      _ORBIT_retval._u.y = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'c':
	   case 'd':
	      _ORBIT_retval._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      (*((guint16 *) & (_ORBIT_retval._u.v.a))) =
		 GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
	      _ORBIT_curptr += 2;
	      break;
	   default:
	      break;
	 }
	 (*inoutArg)._d = *((CORBA_char *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 switch ((*inoutArg)._d) {
	   case 'a':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	      (*((guint32 *) & ((*inoutArg)._u.x))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      break;
	   case 'b':
	      (*inoutArg)._u.y = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'c':
	   case 'd':
	      (*inoutArg)._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      (*((guint16 *) & ((*inoutArg)._u.v.a))) =
		 GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
	      _ORBIT_curptr += 2;
	      break;
	   default:
	      break;
	 }
	 (*outArg)._d = *((CORBA_char *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 switch ((*outArg)._d) {
	   case 'a':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	      (*((guint32 *) & ((*outArg)._u.x))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      break;
	   case 'b':
	      (*outArg)._u.y = *((CORBA_char *) _ORBIT_curptr);
	      break;
	   case 'c':
	   case 'd':
	      (*outArg)._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      (*((guint16 *) & ((*outArg)._u.v.a))) =
		 GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
	      break;
	   default:
	      break;
	 }
      } else {
	 _ORBIT_retval._d = *((CORBA_char *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 switch (_ORBIT_retval._d) {
	   case 'a':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	      _ORBIT_retval._u.x = *((CORBA_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      break;
	   case 'b':
	      _ORBIT_retval._u.y = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'c':
	   case 'd':
	      _ORBIT_retval._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      memcpy(&(_ORBIT_retval._u.v), _ORBIT_curptr,
		     sizeof(_ORBIT_retval._u.v));
	      _ORBIT_curptr += sizeof(_ORBIT_retval._u.v);
	      break;
	   default:
	      break;
	 }
	 (*inoutArg)._d = *((CORBA_char *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 switch ((*inoutArg)._d) {
	   case 'a':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	      (*inoutArg)._u.x = *((CORBA_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      break;
	   case 'b':
	      (*inoutArg)._u.y = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'c':
	   case 'd':
	      (*inoutArg)._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      memcpy(&((*inoutArg)._u.v), _ORBIT_curptr,
		     sizeof((*inoutArg)._u.v));
	      _ORBIT_curptr += sizeof((*inoutArg)._u.v);
	      break;
	   default:
	      break;
	 }
	 (*outArg)._d = *((CORBA_char *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 switch ((*outArg)._d) {
	   case 'a':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	      (*outArg)._u.x = *((CORBA_long *) _ORBIT_curptr);
	      break;
	   case 'b':
	      (*outArg)._u.y = *((CORBA_char *) _ORBIT_curptr);
	      break;
	   case 'c':
	   case 'd':
	      (*outArg)._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      memcpy(&((*outArg)._u.v), _ORBIT_curptr,
		     sizeof((*outArg)._u.v));
	      break;
	   default:
	      break;
	 }
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
test_VariableLengthUnion *
test_UnionServer_opVariable(test_UnionServer _obj,
			    const test_VariableLengthUnion * inArg,
			    test_VariableLengthUnion * inoutArg,
			    test_VariableLengthUnion ** outArg,
			    CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   test_VariableLengthUnion *_ORBIT_retval;
   register CORBA_unsigned_long _ORBIT_tmpvar_50;
   CORBA_unsigned_long _ORBIT_tmpvar_51;
   register CORBA_unsigned_long _ORBIT_tmpvar_52;
   CORBA_unsigned_long _ORBIT_tmpvar_53;
   register CORBA_unsigned_long _ORBIT_tmpvar_54;
   register CORBA_unsigned_long _ORBIT_tmpvar_55;
   CORBA_unsigned_long _ORBIT_tmpvar_56;
   register CORBA_unsigned_long _ORBIT_tmpvar_57;
   register CORBA_unsigned_long _ORBIT_tmpvar_58;
   CORBA_unsigned_long _ORBIT_tmpvar_59;
   register CORBA_unsigned_long _ORBIT_tmpvar_60;
   CORBA_unsigned_long _ORBIT_tmpvar_61;
   register CORBA_unsigned_long _ORBIT_tmpvar_62;
   CORBA_unsigned_long _ORBIT_tmpvar_63;
   register CORBA_unsigned_long _ORBIT_tmpvar_64;
   register CORBA_unsigned_long _ORBIT_tmpvar_65;
   CORBA_unsigned_long _ORBIT_tmpvar_66;
   register CORBA_unsigned_long _ORBIT_tmpvar_67;
   register CORBA_unsigned_long _ORBIT_tmpvar_68;
   CORBA_unsigned_long _ORBIT_tmpvar_69;
   register CORBA_unsigned_long _ORBIT_tmpvar_70;
   CORBA_unsigned_long _ORBIT_tmpvar_71;
   register CORBA_unsigned_long _ORBIT_tmpvar_72;
   CORBA_unsigned_long _ORBIT_tmpvar_73;
   register CORBA_unsigned_long _ORBIT_tmpvar_74;
   register CORBA_unsigned_long _ORBIT_tmpvar_75;
   CORBA_unsigned_long _ORBIT_tmpvar_76;
   register CORBA_unsigned_long _ORBIT_tmpvar_77;
   register CORBA_unsigned_long _ORBIT_tmpvar_78;
   CORBA_unsigned_long _ORBIT_tmpvar_79;

   if (_obj->servant && _obj->vepv && test_UnionServer__classid) {
      _ORBIT_retval =
	 ((POA_test_UnionServer__epv *) _obj->
	  vepv[test_UnionServer__classid])->opVariable(_obj->servant, inArg,
						       inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[11];
      }
      _ORBIT_operation_name_data =
      {
      11, "opVariable"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 15 };
      register CORBA_unsigned_long _ORBIT_tmpvar_0;
      CORBA_unsigned_long _ORBIT_tmpvar_1;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;
      register CORBA_unsigned_long _ORBIT_tmpvar_4;
      register CORBA_unsigned_long _ORBIT_tmpvar_5;
      CORBA_unsigned_long _ORBIT_tmpvar_6;
      register CORBA_unsigned_long _ORBIT_tmpvar_7;
      register CORBA_unsigned_long _ORBIT_tmpvar_8;
      CORBA_unsigned_long _ORBIT_tmpvar_9;
      register CORBA_unsigned_long _ORBIT_tmpvar_10;
      CORBA_unsigned_long _ORBIT_tmpvar_11;
      register CORBA_unsigned_long _ORBIT_tmpvar_12;
      CORBA_unsigned_long _ORBIT_tmpvar_13;
      register CORBA_unsigned_long _ORBIT_tmpvar_14;
      register CORBA_unsigned_long _ORBIT_tmpvar_15;
      CORBA_unsigned_long _ORBIT_tmpvar_16;
      register CORBA_unsigned_long _ORBIT_tmpvar_17;
      register CORBA_unsigned_long _ORBIT_tmpvar_18;
      CORBA_unsigned_long _ORBIT_tmpvar_19;

      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &((*inArg)._d), sizeof((*inArg)._d));
      switch ((*inArg)._d) {
	case 1:
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inArg)._u.x),
					  sizeof((*inArg)._u.x));
	   break;
	default:
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inArg)._u.w),
					  sizeof((*inArg)._u.w));
	   break;
	case 2:
	   _ORBIT_tmpvar_1 = strlen((*inArg)._u.y) + 1;
	   {
	      guchar *_ORBIT_t;

	      _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_1));
	      memcpy(_ORBIT_t, &(_ORBIT_tmpvar_1), sizeof(_ORBIT_tmpvar_1));
	      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), (_ORBIT_t),
					     sizeof(_ORBIT_tmpvar_1));
	   }
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  ((*inArg)._u.y),
					  sizeof((*inArg)._u.
						 y[_ORBIT_tmpvar_0]) *
					  _ORBIT_tmpvar_1);
	   break;
	case 3:
	case 4:
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inArg)._u.z),
					  sizeof((*inArg)._u.z));
	   break;
	case 5:
	   _ORBIT_tmpvar_3 = strlen((*inArg)._u.a.a) + 1;
	   {
	      guchar *_ORBIT_t;

	      _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_3));
	      memcpy(_ORBIT_t, &(_ORBIT_tmpvar_3), sizeof(_ORBIT_tmpvar_3));
	      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), (_ORBIT_t),
					     sizeof(_ORBIT_tmpvar_3));
	   }
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  ((*inArg)._u.a.a),
					  sizeof((*inArg)._u.a.
						 a[_ORBIT_tmpvar_2]) *
					  _ORBIT_tmpvar_3);
	   break;
	case 6:
	   {
	      guchar *_ORBIT_t;

	      _ORBIT_t = alloca(sizeof((*inArg)._u.b._length));
	      memcpy(_ORBIT_t, &((*inArg)._u.b._length),
		     sizeof((*inArg)._u.b._length));
	      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), (_ORBIT_t),
					     sizeof((*inArg)._u.b._length));
	   }
	   for (_ORBIT_tmpvar_4 = 0; _ORBIT_tmpvar_4 < (*inArg)._u.b._length;
		_ORBIT_tmpvar_4++) {
	      _ORBIT_tmpvar_6 =
		 strlen((*inArg)._u.b._buffer[_ORBIT_tmpvar_4]) + 1;
	      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer), 4);
	      {
		 guchar *_ORBIT_t;

		 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_6));
		 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_6),
			sizeof(_ORBIT_tmpvar_6));
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						(_ORBIT_t),
						sizeof(_ORBIT_tmpvar_6));
	      }
	      {
		 guchar *_ORBIT_t;

		 _ORBIT_t =
		    alloca(sizeof
			   ((*inArg)._u.b.
			    _buffer[_ORBIT_tmpvar_4][_ORBIT_tmpvar_5]) *
			   _ORBIT_tmpvar_6);
		 memcpy(_ORBIT_t, ((*inArg)._u.b._buffer[_ORBIT_tmpvar_4]),
			sizeof((*inArg)._u.b.
			       _buffer[_ORBIT_tmpvar_4][_ORBIT_tmpvar_5]) *
			_ORBIT_tmpvar_6);
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						(_ORBIT_t),
						sizeof((*inArg)._u.b.
						       _buffer
						       [_ORBIT_tmpvar_4]
						       [_ORBIT_tmpvar_5]) *
						_ORBIT_tmpvar_6);
	      }
	   }

	   break;
	case 7:
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inArg)._u.c._d),
					  sizeof((*inArg)._u.c._d));
	   switch ((*inArg)._u.c._d) {
	     case 'a':
		giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer), 4);
		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer),
					       &((*inArg)._u.c._u.x),
					       sizeof((*inArg)._u.c._u.x));
		break;
	     case 'b':
		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer),
					       &((*inArg)._u.c._u.y),
					       sizeof((*inArg)._u.c._u.y));
		break;
	     case 'c':
	     case 'd':
		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer),
					       &((*inArg)._u.c._u.z),
					       sizeof((*inArg)._u.c._u.z));
		break;
	     case 'e':
		giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer), 2);
		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer),
					       &((*inArg)._u.c._u.v),
					       sizeof((*inArg)._u.c._u.v));
		break;
	     default:
		break;
	   }
	   break;
	case 8:
	   for (_ORBIT_tmpvar_7 = 0; _ORBIT_tmpvar_7 < 2; _ORBIT_tmpvar_7++) {
	      _ORBIT_tmpvar_9 = strlen((*inArg)._u.d[_ORBIT_tmpvar_7]) + 1;
	      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer), 4);
	      {
		 guchar *_ORBIT_t;

		 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_9));
		 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_9),
			sizeof(_ORBIT_tmpvar_9));
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						(_ORBIT_t),
						sizeof(_ORBIT_tmpvar_9));
	      }
	      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer),
					     ((*inArg)._u.d[_ORBIT_tmpvar_7]),
					     sizeof((*inArg)._u.
						    d[_ORBIT_tmpvar_7]
						    [_ORBIT_tmpvar_8]) *
					     _ORBIT_tmpvar_9);
	   }

	   break;
      }
      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
				       (_ORBIT_send_buffer), 4);
      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				     &((*inoutArg)._d),
				     sizeof((*inoutArg)._d));
      switch ((*inoutArg)._d) {
	case 1:
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inoutArg)._u.x),
					  sizeof((*inoutArg)._u.x));
	   break;
	default:
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inoutArg)._u.w),
					  sizeof((*inoutArg)._u.w));
	   break;
	case 2:
	   _ORBIT_tmpvar_11 = strlen((*inoutArg)._u.y) + 1;
	   {
	      guchar *_ORBIT_t;

	      _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_11));
	      memcpy(_ORBIT_t, &(_ORBIT_tmpvar_11), sizeof(_ORBIT_tmpvar_11));
	      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), (_ORBIT_t),
					     sizeof(_ORBIT_tmpvar_11));
	   }
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  ((*inoutArg)._u.y),
					  sizeof((*inoutArg)._u.
						 y[_ORBIT_tmpvar_10]) *
					  _ORBIT_tmpvar_11);
	   break;
	case 3:
	case 4:
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inoutArg)._u.z),
					  sizeof((*inoutArg)._u.z));
	   break;
	case 5:
	   _ORBIT_tmpvar_13 = strlen((*inoutArg)._u.a.a) + 1;
	   {
	      guchar *_ORBIT_t;

	      _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_13));
	      memcpy(_ORBIT_t, &(_ORBIT_tmpvar_13), sizeof(_ORBIT_tmpvar_13));
	      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), (_ORBIT_t),
					     sizeof(_ORBIT_tmpvar_13));
	   }
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  ((*inoutArg)._u.a.a),
					  sizeof((*inoutArg)._u.a.
						 a[_ORBIT_tmpvar_12]) *
					  _ORBIT_tmpvar_13);
	   break;
	case 6:
	   {
	      guchar *_ORBIT_t;

	      _ORBIT_t = alloca(sizeof((*inoutArg)._u.b._length));
	      memcpy(_ORBIT_t, &((*inoutArg)._u.b._length),
		     sizeof((*inoutArg)._u.b._length));
	      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), (_ORBIT_t),
					     sizeof((*inoutArg)._u.b.
						    _length));
	   }
	   for (_ORBIT_tmpvar_14 = 0;
		_ORBIT_tmpvar_14 < (*inoutArg)._u.b._length;
		_ORBIT_tmpvar_14++) {
	      _ORBIT_tmpvar_16 =
		 strlen((*inoutArg)._u.b._buffer[_ORBIT_tmpvar_14]) + 1;
	      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer), 4);
	      {
		 guchar *_ORBIT_t;

		 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_16));
		 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_16),
			sizeof(_ORBIT_tmpvar_16));
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						(_ORBIT_t),
						sizeof(_ORBIT_tmpvar_16));
	      }
	      {
		 guchar *_ORBIT_t;

		 _ORBIT_t =
		    alloca(sizeof
			   ((*inoutArg)._u.b.
			    _buffer[_ORBIT_tmpvar_14][_ORBIT_tmpvar_15]) *
			   _ORBIT_tmpvar_16);
		 memcpy(_ORBIT_t,
			((*inoutArg)._u.b._buffer[_ORBIT_tmpvar_14]),
			sizeof((*inoutArg)._u.b.
			       _buffer[_ORBIT_tmpvar_14][_ORBIT_tmpvar_15]) *
			_ORBIT_tmpvar_16);
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						(_ORBIT_t),
						sizeof((*inoutArg)._u.b.
						       _buffer
						       [_ORBIT_tmpvar_14]
						       [_ORBIT_tmpvar_15]) *
						_ORBIT_tmpvar_16);
	      }
	   }

	   break;
	case 7:
	   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					  (_ORBIT_send_buffer),
					  &((*inoutArg)._u.c._d),
					  sizeof((*inoutArg)._u.c._d));
	   switch ((*inoutArg)._u.c._d) {
	     case 'a':
		giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer), 4);
		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer),
					       &((*inoutArg)._u.c._u.x),
					       sizeof((*inoutArg)._u.c._u.x));
		break;
	     case 'b':
		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer),
					       &((*inoutArg)._u.c._u.y),
					       sizeof((*inoutArg)._u.c._u.y));
		break;
	     case 'c':
	     case 'd':
		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer),
					       &((*inoutArg)._u.c._u.z),
					       sizeof((*inoutArg)._u.c._u.z));
		break;
	     case 'e':
		giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer), 2);
		giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer),
					       &((*inoutArg)._u.c._u.v),
					       sizeof((*inoutArg)._u.c._u.v));
		break;
	     default:
		break;
	   }
	   break;
	case 8:
	   for (_ORBIT_tmpvar_17 = 0; _ORBIT_tmpvar_17 < 2;
		_ORBIT_tmpvar_17++) {
	      _ORBIT_tmpvar_19 =
		 strlen((*inoutArg)._u.d[_ORBIT_tmpvar_17]) + 1;
	      giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					       (_ORBIT_send_buffer), 4);
	      {
		 guchar *_ORBIT_t;

		 _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_19));
		 memcpy(_ORBIT_t, &(_ORBIT_tmpvar_19),
			sizeof(_ORBIT_tmpvar_19));
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						(_ORBIT_t),
						sizeof(_ORBIT_tmpvar_19));
	      }
	      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer),
					     ((*inoutArg)._u.
					      d[_ORBIT_tmpvar_17]),
					     sizeof((*inoutArg)._u.
						    d[_ORBIT_tmpvar_17]
						    [_ORBIT_tmpvar_18]) *
					     _ORBIT_tmpvar_19);
	   }

	   break;
      }
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   test_VariableLengthUnion__free(inoutArg, NULL, CORBA_TRUE);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = test_VariableLengthUnion__alloc();
      *outArg = test_VariableLengthUnion__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & ((*_ORBIT_retval)._d))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 switch ((*_ORBIT_retval)._d) {
	   case 1:
	      (*((guint32 *) & ((*_ORBIT_retval)._u.x))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      break;
	   default:
	      (*((guint32 *) & ((*_ORBIT_retval)._u.w))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      break;
	   case 2:
	      (*((guint32 *) & (_ORBIT_tmpvar_51))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      (*_ORBIT_retval)._u.y = CORBA_string_alloc(_ORBIT_tmpvar_51);
	      memcpy((*_ORBIT_retval)._u.y, _ORBIT_curptr,
		     sizeof((*_ORBIT_retval)._u.y[_ORBIT_tmpvar_50]) *
		     _ORBIT_tmpvar_51);
	      _ORBIT_curptr +=
		 sizeof((*_ORBIT_retval)._u.y[_ORBIT_tmpvar_50]) *
		 _ORBIT_tmpvar_51;
	      break;
	   case 3:
	   case 4:
	      (*_ORBIT_retval)._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 5:
	      (*((guint32 *) & (_ORBIT_tmpvar_53))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      (*_ORBIT_retval)._u.a.a = CORBA_string_alloc(_ORBIT_tmpvar_53);
	      memcpy((*_ORBIT_retval)._u.a.a, _ORBIT_curptr,
		     sizeof((*_ORBIT_retval)._u.a.a[_ORBIT_tmpvar_52]) *
		     _ORBIT_tmpvar_53);
	      _ORBIT_curptr +=
		 sizeof((*_ORBIT_retval)._u.a.a[_ORBIT_tmpvar_52]) *
		 _ORBIT_tmpvar_53;
	      break;
	   case 6:
	      (*((guint32 *) & ((*_ORBIT_retval)._u.b._length))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      (*_ORBIT_retval)._u.b._maximum = (*_ORBIT_retval)._u.b._length;
	      (*_ORBIT_retval)._u.b._buffer =
		 CORBA_sequence_CORBA_string_allocbuf((*_ORBIT_retval)._u.b.
						      _length);
	      (*_ORBIT_retval)._u.b._release = CORBA_TRUE;
	      for (_ORBIT_tmpvar_54 = 0;
		   _ORBIT_tmpvar_54 < (*_ORBIT_retval)._u.b._length;
		   _ORBIT_tmpvar_54++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 (*((guint32 *) & (_ORBIT_tmpvar_56))) =
		    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		 _ORBIT_curptr += 4;
		 (*_ORBIT_retval)._u.b._buffer[_ORBIT_tmpvar_54] =
		    CORBA_string_alloc(_ORBIT_tmpvar_56);
		 memcpy((*_ORBIT_retval)._u.b._buffer[_ORBIT_tmpvar_54],
			_ORBIT_curptr,
			sizeof((*_ORBIT_retval)._u.b.
			       _buffer[_ORBIT_tmpvar_54][_ORBIT_tmpvar_55]) *
			_ORBIT_tmpvar_56);
		 _ORBIT_curptr +=
		    sizeof((*_ORBIT_retval)._u.b.
			   _buffer[_ORBIT_tmpvar_54][_ORBIT_tmpvar_55]) *
		    _ORBIT_tmpvar_56;
	      }

	      break;
	   case 7:
	      (*_ORBIT_retval)._u.c._d = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      switch ((*_ORBIT_retval)._u.c._d) {
		case 'a':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		   (*((guint32 *) & ((*_ORBIT_retval)._u.c._u.x))) =
		      GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		   _ORBIT_curptr += 4;
		   break;
		case 'b':
		   (*_ORBIT_retval)._u.c._u.y =
		      *((CORBA_char *) _ORBIT_curptr);
		   _ORBIT_curptr += 1;
		   break;
		case 'c':
		case 'd':
		   (*_ORBIT_retval)._u.c._u.z =
		      *((CORBA_boolean *) _ORBIT_curptr);
		   _ORBIT_curptr += 1;
		   break;
		case 'e':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
		   (*((guint16 *) & ((*_ORBIT_retval)._u.c._u.v.a))) =
		      GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
		   _ORBIT_curptr += 2;
		   break;
		default:
		   break;
	      }
	      break;
	   case 8:
	      for (_ORBIT_tmpvar_57 = 0; _ORBIT_tmpvar_57 < 2;
		   _ORBIT_tmpvar_57++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 (*((guint32 *) & (_ORBIT_tmpvar_59))) =
		    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		 _ORBIT_curptr += 4;
		 (*_ORBIT_retval)._u.d[_ORBIT_tmpvar_57] =
		    CORBA_string_alloc(_ORBIT_tmpvar_59);
		 memcpy((*_ORBIT_retval)._u.d[_ORBIT_tmpvar_57],
			_ORBIT_curptr,
			sizeof((*_ORBIT_retval)._u.
			       d[_ORBIT_tmpvar_57][_ORBIT_tmpvar_58]) *
			_ORBIT_tmpvar_59);
		 _ORBIT_curptr +=
		    sizeof((*_ORBIT_retval)._u.
			   d[_ORBIT_tmpvar_57][_ORBIT_tmpvar_58]) *
		    _ORBIT_tmpvar_59;
	      }

	      break;
	 }
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & ((*inoutArg)._d))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 switch ((*inoutArg)._d) {
	   case 1:
	      (*((guint32 *) & ((*inoutArg)._u.x))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      break;
	   default:
	      (*((guint32 *) & ((*inoutArg)._u.w))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      break;
	   case 2:
	      (*((guint32 *) & (_ORBIT_tmpvar_61))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      (*inoutArg)._u.y = CORBA_string_alloc(_ORBIT_tmpvar_61);
	      memcpy((*inoutArg)._u.y, _ORBIT_curptr,
		     sizeof((*inoutArg)._u.y[_ORBIT_tmpvar_60]) *
		     _ORBIT_tmpvar_61);
	      _ORBIT_curptr +=
		 sizeof((*inoutArg)._u.y[_ORBIT_tmpvar_60]) *
		 _ORBIT_tmpvar_61;
	      break;
	   case 3:
	   case 4:
	      (*inoutArg)._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 5:
	      (*((guint32 *) & (_ORBIT_tmpvar_63))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      (*inoutArg)._u.a.a = CORBA_string_alloc(_ORBIT_tmpvar_63);
	      memcpy((*inoutArg)._u.a.a, _ORBIT_curptr,
		     sizeof((*inoutArg)._u.a.a[_ORBIT_tmpvar_62]) *
		     _ORBIT_tmpvar_63);
	      _ORBIT_curptr +=
		 sizeof((*inoutArg)._u.a.a[_ORBIT_tmpvar_62]) *
		 _ORBIT_tmpvar_63;
	      break;
	   case 6:
	      (*((guint32 *) & ((*inoutArg)._u.b._length))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      (*inoutArg)._u.b._maximum = (*inoutArg)._u.b._length;
	      (*inoutArg)._u.b._buffer =
		 CORBA_sequence_CORBA_string_allocbuf((*inoutArg)._u.b.
						      _length);
	      (*inoutArg)._u.b._release = CORBA_TRUE;
	      for (_ORBIT_tmpvar_64 = 0;
		   _ORBIT_tmpvar_64 < (*inoutArg)._u.b._length;
		   _ORBIT_tmpvar_64++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 (*((guint32 *) & (_ORBIT_tmpvar_66))) =
		    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		 _ORBIT_curptr += 4;
		 (*inoutArg)._u.b._buffer[_ORBIT_tmpvar_64] =
		    CORBA_string_alloc(_ORBIT_tmpvar_66);
		 memcpy((*inoutArg)._u.b._buffer[_ORBIT_tmpvar_64],
			_ORBIT_curptr,
			sizeof((*inoutArg)._u.b.
			       _buffer[_ORBIT_tmpvar_64][_ORBIT_tmpvar_65]) *
			_ORBIT_tmpvar_66);
		 _ORBIT_curptr +=
		    sizeof((*inoutArg)._u.b.
			   _buffer[_ORBIT_tmpvar_64][_ORBIT_tmpvar_65]) *
		    _ORBIT_tmpvar_66;
	      }

	      break;
	   case 7:
	      (*inoutArg)._u.c._d = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      switch ((*inoutArg)._u.c._d) {
		case 'a':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		   (*((guint32 *) & ((*inoutArg)._u.c._u.x))) =
		      GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		   _ORBIT_curptr += 4;
		   break;
		case 'b':
		   (*inoutArg)._u.c._u.y = *((CORBA_char *) _ORBIT_curptr);
		   _ORBIT_curptr += 1;
		   break;
		case 'c':
		case 'd':
		   (*inoutArg)._u.c._u.z = *((CORBA_boolean *) _ORBIT_curptr);
		   _ORBIT_curptr += 1;
		   break;
		case 'e':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
		   (*((guint16 *) & ((*inoutArg)._u.c._u.v.a))) =
		      GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
		   _ORBIT_curptr += 2;
		   break;
		default:
		   break;
	      }
	      break;
	   case 8:
	      for (_ORBIT_tmpvar_67 = 0; _ORBIT_tmpvar_67 < 2;
		   _ORBIT_tmpvar_67++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 (*((guint32 *) & (_ORBIT_tmpvar_69))) =
		    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		 _ORBIT_curptr += 4;
		 (*inoutArg)._u.d[_ORBIT_tmpvar_67] =
		    CORBA_string_alloc(_ORBIT_tmpvar_69);
		 memcpy((*inoutArg)._u.d[_ORBIT_tmpvar_67], _ORBIT_curptr,
			sizeof((*inoutArg)._u.
			       d[_ORBIT_tmpvar_67][_ORBIT_tmpvar_68]) *
			_ORBIT_tmpvar_69);
		 _ORBIT_curptr +=
		    sizeof((*inoutArg)._u.
			   d[_ORBIT_tmpvar_67][_ORBIT_tmpvar_68]) *
		    _ORBIT_tmpvar_69;
	      }

	      break;
	 }
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (((**outArg))._d))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 switch (((**outArg))._d) {
	   case 1:
	      (*((guint32 *) & (((**outArg))._u.x))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      break;
	   default:
	      (*((guint32 *) & (((**outArg))._u.w))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      break;
	   case 2:
	      (*((guint32 *) & (_ORBIT_tmpvar_71))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      ((**outArg))._u.y = CORBA_string_alloc(_ORBIT_tmpvar_71);
	      memcpy(((**outArg))._u.y, _ORBIT_curptr,
		     sizeof(((**outArg))._u.y[_ORBIT_tmpvar_70]) *
		     _ORBIT_tmpvar_71);
	      _ORBIT_curptr +=
		 sizeof(((**outArg))._u.y[_ORBIT_tmpvar_70]) *
		 _ORBIT_tmpvar_71;
	      break;
	   case 3:
	   case 4:
	      ((**outArg))._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      break;
	   case 5:
	      (*((guint32 *) & (_ORBIT_tmpvar_73))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      ((**outArg))._u.a.a = CORBA_string_alloc(_ORBIT_tmpvar_73);
	      memcpy(((**outArg))._u.a.a, _ORBIT_curptr,
		     sizeof(((**outArg))._u.a.a[_ORBIT_tmpvar_72]) *
		     _ORBIT_tmpvar_73);
	      _ORBIT_curptr +=
		 sizeof(((**outArg))._u.a.a[_ORBIT_tmpvar_72]) *
		 _ORBIT_tmpvar_73;
	      break;
	   case 6:
	      (*((guint32 *) & (((**outArg))._u.b._length))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      ((**outArg))._u.b._maximum = ((**outArg))._u.b._length;
	      ((**outArg))._u.b._buffer =
		 CORBA_sequence_CORBA_string_allocbuf(((**outArg))._u.b.
						      _length);
	      ((**outArg))._u.b._release = CORBA_TRUE;
	      for (_ORBIT_tmpvar_74 = 0;
		   _ORBIT_tmpvar_74 < ((**outArg))._u.b._length;
		   _ORBIT_tmpvar_74++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 (*((guint32 *) & (_ORBIT_tmpvar_76))) =
		    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		 _ORBIT_curptr += 4;
		 ((**outArg))._u.b._buffer[_ORBIT_tmpvar_74] =
		    CORBA_string_alloc(_ORBIT_tmpvar_76);
		 memcpy(((**outArg))._u.b._buffer[_ORBIT_tmpvar_74],
			_ORBIT_curptr,
			sizeof(((**outArg))._u.b.
			       _buffer[_ORBIT_tmpvar_74][_ORBIT_tmpvar_75]) *
			_ORBIT_tmpvar_76);
		 _ORBIT_curptr +=
		    sizeof(((**outArg))._u.b.
			   _buffer[_ORBIT_tmpvar_74][_ORBIT_tmpvar_75]) *
		    _ORBIT_tmpvar_76;
	      }

	      break;
	   case 7:
	      ((**outArg))._u.c._d = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      switch (((**outArg))._u.c._d) {
		case 'a':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		   (*((guint32 *) & (((**outArg))._u.c._u.x))) =
		      GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		   break;
		case 'b':
		   ((**outArg))._u.c._u.y = *((CORBA_char *) _ORBIT_curptr);
		   break;
		case 'c':
		case 'd':
		   ((**outArg))._u.c._u.z =
		      *((CORBA_boolean *) _ORBIT_curptr);
		   break;
		case 'e':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
		   (*((guint16 *) & (((**outArg))._u.c._u.v.a))) =
		      GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
		   break;
		default:
		   break;
	      }
	      break;
	   case 8:
	      for (_ORBIT_tmpvar_77 = 0; _ORBIT_tmpvar_77 < 2;
		   _ORBIT_tmpvar_77++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 (*((guint32 *) & (_ORBIT_tmpvar_79))) =
		    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		 _ORBIT_curptr += 4;
		 ((**outArg))._u.d[_ORBIT_tmpvar_77] =
		    CORBA_string_alloc(_ORBIT_tmpvar_79);
		 memcpy(((**outArg))._u.d[_ORBIT_tmpvar_77], _ORBIT_curptr,
			sizeof(((**outArg))._u.
			       d[_ORBIT_tmpvar_77][_ORBIT_tmpvar_78]) *
			_ORBIT_tmpvar_79);
		 _ORBIT_curptr +=
		    sizeof(((**outArg))._u.
			   d[_ORBIT_tmpvar_77][_ORBIT_tmpvar_78]) *
		    _ORBIT_tmpvar_79;
	      }

	      break;
	 }
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*_ORBIT_retval)._d = *((CORBA_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 switch ((*_ORBIT_retval)._d) {
	   case 1:
	      (*_ORBIT_retval)._u.x = *((CORBA_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      break;
	   default:
	      (*_ORBIT_retval)._u.w = *((CORBA_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      break;
	   case 2:
	      _ORBIT_tmpvar_51 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      (*_ORBIT_retval)._u.y = CORBA_string_alloc(_ORBIT_tmpvar_51);
	      memcpy((*_ORBIT_retval)._u.y, _ORBIT_curptr,
		     sizeof((*_ORBIT_retval)._u.y[_ORBIT_tmpvar_50]) *
		     _ORBIT_tmpvar_51);
	      _ORBIT_curptr +=
		 sizeof((*_ORBIT_retval)._u.y[_ORBIT_tmpvar_50]) *
		 _ORBIT_tmpvar_51;
	      break;
	   case 3:
	   case 4:
	      (*_ORBIT_retval)._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 5:
	      _ORBIT_tmpvar_53 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      (*_ORBIT_retval)._u.a.a = CORBA_string_alloc(_ORBIT_tmpvar_53);
	      memcpy((*_ORBIT_retval)._u.a.a, _ORBIT_curptr,
		     sizeof((*_ORBIT_retval)._u.a.a[_ORBIT_tmpvar_52]) *
		     _ORBIT_tmpvar_53);
	      _ORBIT_curptr +=
		 sizeof((*_ORBIT_retval)._u.a.a[_ORBIT_tmpvar_52]) *
		 _ORBIT_tmpvar_53;
	      break;
	   case 6:
	      (*_ORBIT_retval)._u.b._length =
		 *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      (*_ORBIT_retval)._u.b._maximum = (*_ORBIT_retval)._u.b._length;
	      (*_ORBIT_retval)._u.b._buffer =
		 CORBA_sequence_CORBA_string_allocbuf((*_ORBIT_retval)._u.b.
						      _length);
	      (*_ORBIT_retval)._u.b._release = CORBA_TRUE;
	      for (_ORBIT_tmpvar_54 = 0;
		   _ORBIT_tmpvar_54 < (*_ORBIT_retval)._u.b._length;
		   _ORBIT_tmpvar_54++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 _ORBIT_tmpvar_56 = *((CORBA_unsigned_long *) _ORBIT_curptr);
		 _ORBIT_curptr += 4;
		 (*_ORBIT_retval)._u.b._buffer[_ORBIT_tmpvar_54] =
		    CORBA_string_alloc(_ORBIT_tmpvar_56);
		 memcpy((*_ORBIT_retval)._u.b._buffer[_ORBIT_tmpvar_54],
			_ORBIT_curptr,
			sizeof((*_ORBIT_retval)._u.b.
			       _buffer[_ORBIT_tmpvar_54][_ORBIT_tmpvar_55]) *
			_ORBIT_tmpvar_56);
		 _ORBIT_curptr +=
		    sizeof((*_ORBIT_retval)._u.b.
			   _buffer[_ORBIT_tmpvar_54][_ORBIT_tmpvar_55]) *
		    _ORBIT_tmpvar_56;
	      }

	      break;
	   case 7:
	      (*_ORBIT_retval)._u.c._d = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      switch ((*_ORBIT_retval)._u.c._d) {
		case 'a':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		   (*_ORBIT_retval)._u.c._u.x =
		      *((CORBA_long *) _ORBIT_curptr);
		   _ORBIT_curptr += 4;
		   break;
		case 'b':
		   (*_ORBIT_retval)._u.c._u.y =
		      *((CORBA_char *) _ORBIT_curptr);
		   _ORBIT_curptr += 1;
		   break;
		case 'c':
		case 'd':
		   (*_ORBIT_retval)._u.c._u.z =
		      *((CORBA_boolean *) _ORBIT_curptr);
		   _ORBIT_curptr += 1;
		   break;
		case 'e':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
		   memcpy(&((*_ORBIT_retval)._u.c._u.v), _ORBIT_curptr,
			  sizeof((*_ORBIT_retval)._u.c._u.v));
		   _ORBIT_curptr += sizeof((*_ORBIT_retval)._u.c._u.v);
		   break;
		default:
		   break;
	      }
	      break;
	   case 8:
	      for (_ORBIT_tmpvar_57 = 0; _ORBIT_tmpvar_57 < 2;
		   _ORBIT_tmpvar_57++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 _ORBIT_tmpvar_59 = *((CORBA_unsigned_long *) _ORBIT_curptr);
		 _ORBIT_curptr += 4;
		 (*_ORBIT_retval)._u.d[_ORBIT_tmpvar_57] =
		    CORBA_string_alloc(_ORBIT_tmpvar_59);
		 memcpy((*_ORBIT_retval)._u.d[_ORBIT_tmpvar_57],
			_ORBIT_curptr,
			sizeof((*_ORBIT_retval)._u.
			       d[_ORBIT_tmpvar_57][_ORBIT_tmpvar_58]) *
			_ORBIT_tmpvar_59);
		 _ORBIT_curptr +=
		    sizeof((*_ORBIT_retval)._u.
			   d[_ORBIT_tmpvar_57][_ORBIT_tmpvar_58]) *
		    _ORBIT_tmpvar_59;
	      }

	      break;
	 }
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*inoutArg)._d = *((CORBA_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 switch ((*inoutArg)._d) {
	   case 1:
	      (*inoutArg)._u.x = *((CORBA_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      break;
	   default:
	      (*inoutArg)._u.w = *((CORBA_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      break;
	   case 2:
	      _ORBIT_tmpvar_61 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      (*inoutArg)._u.y = CORBA_string_alloc(_ORBIT_tmpvar_61);
	      memcpy((*inoutArg)._u.y, _ORBIT_curptr,
		     sizeof((*inoutArg)._u.y[_ORBIT_tmpvar_60]) *
		     _ORBIT_tmpvar_61);
	      _ORBIT_curptr +=
		 sizeof((*inoutArg)._u.y[_ORBIT_tmpvar_60]) *
		 _ORBIT_tmpvar_61;
	      break;
	   case 3:
	   case 4:
	      (*inoutArg)._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 5:
	      _ORBIT_tmpvar_63 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      (*inoutArg)._u.a.a = CORBA_string_alloc(_ORBIT_tmpvar_63);
	      memcpy((*inoutArg)._u.a.a, _ORBIT_curptr,
		     sizeof((*inoutArg)._u.a.a[_ORBIT_tmpvar_62]) *
		     _ORBIT_tmpvar_63);
	      _ORBIT_curptr +=
		 sizeof((*inoutArg)._u.a.a[_ORBIT_tmpvar_62]) *
		 _ORBIT_tmpvar_63;
	      break;
	   case 6:
	      (*inoutArg)._u.b._length =
		 *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      (*inoutArg)._u.b._maximum = (*inoutArg)._u.b._length;
	      (*inoutArg)._u.b._buffer =
		 CORBA_sequence_CORBA_string_allocbuf((*inoutArg)._u.b.
						      _length);
	      (*inoutArg)._u.b._release = CORBA_TRUE;
	      for (_ORBIT_tmpvar_64 = 0;
		   _ORBIT_tmpvar_64 < (*inoutArg)._u.b._length;
		   _ORBIT_tmpvar_64++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 _ORBIT_tmpvar_66 = *((CORBA_unsigned_long *) _ORBIT_curptr);
		 _ORBIT_curptr += 4;
		 (*inoutArg)._u.b._buffer[_ORBIT_tmpvar_64] =
		    CORBA_string_alloc(_ORBIT_tmpvar_66);
		 memcpy((*inoutArg)._u.b._buffer[_ORBIT_tmpvar_64],
			_ORBIT_curptr,
			sizeof((*inoutArg)._u.b.
			       _buffer[_ORBIT_tmpvar_64][_ORBIT_tmpvar_65]) *
			_ORBIT_tmpvar_66);
		 _ORBIT_curptr +=
		    sizeof((*inoutArg)._u.b.
			   _buffer[_ORBIT_tmpvar_64][_ORBIT_tmpvar_65]) *
		    _ORBIT_tmpvar_66;
	      }

	      break;
	   case 7:
	      (*inoutArg)._u.c._d = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      switch ((*inoutArg)._u.c._d) {
		case 'a':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		   (*inoutArg)._u.c._u.x = *((CORBA_long *) _ORBIT_curptr);
		   _ORBIT_curptr += 4;
		   break;
		case 'b':
		   (*inoutArg)._u.c._u.y = *((CORBA_char *) _ORBIT_curptr);
		   _ORBIT_curptr += 1;
		   break;
		case 'c':
		case 'd':
		   (*inoutArg)._u.c._u.z = *((CORBA_boolean *) _ORBIT_curptr);
		   _ORBIT_curptr += 1;
		   break;
		case 'e':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
		   memcpy(&((*inoutArg)._u.c._u.v), _ORBIT_curptr,
			  sizeof((*inoutArg)._u.c._u.v));
		   _ORBIT_curptr += sizeof((*inoutArg)._u.c._u.v);
		   break;
		default:
		   break;
	      }
	      break;
	   case 8:
	      for (_ORBIT_tmpvar_67 = 0; _ORBIT_tmpvar_67 < 2;
		   _ORBIT_tmpvar_67++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 _ORBIT_tmpvar_69 = *((CORBA_unsigned_long *) _ORBIT_curptr);
		 _ORBIT_curptr += 4;
		 (*inoutArg)._u.d[_ORBIT_tmpvar_67] =
		    CORBA_string_alloc(_ORBIT_tmpvar_69);
		 memcpy((*inoutArg)._u.d[_ORBIT_tmpvar_67], _ORBIT_curptr,
			sizeof((*inoutArg)._u.
			       d[_ORBIT_tmpvar_67][_ORBIT_tmpvar_68]) *
			_ORBIT_tmpvar_69);
		 _ORBIT_curptr +=
		    sizeof((*inoutArg)._u.
			   d[_ORBIT_tmpvar_67][_ORBIT_tmpvar_68]) *
		    _ORBIT_tmpvar_69;
	      }

	      break;
	 }
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 ((**outArg))._d = *((CORBA_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 switch (((**outArg))._d) {
	   case 1:
	      ((**outArg))._u.x = *((CORBA_long *) _ORBIT_curptr);
	      break;
	   default:
	      ((**outArg))._u.w = *((CORBA_long *) _ORBIT_curptr);
	      break;
	   case 2:
	      _ORBIT_tmpvar_71 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      ((**outArg))._u.y = CORBA_string_alloc(_ORBIT_tmpvar_71);
	      memcpy(((**outArg))._u.y, _ORBIT_curptr,
		     sizeof(((**outArg))._u.y[_ORBIT_tmpvar_70]) *
		     _ORBIT_tmpvar_71);
	      _ORBIT_curptr +=
		 sizeof(((**outArg))._u.y[_ORBIT_tmpvar_70]) *
		 _ORBIT_tmpvar_71;
	      break;
	   case 3:
	   case 4:
	      ((**outArg))._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      break;
	   case 5:
	      _ORBIT_tmpvar_73 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      ((**outArg))._u.a.a = CORBA_string_alloc(_ORBIT_tmpvar_73);
	      memcpy(((**outArg))._u.a.a, _ORBIT_curptr,
		     sizeof(((**outArg))._u.a.a[_ORBIT_tmpvar_72]) *
		     _ORBIT_tmpvar_73);
	      _ORBIT_curptr +=
		 sizeof(((**outArg))._u.a.a[_ORBIT_tmpvar_72]) *
		 _ORBIT_tmpvar_73;
	      break;
	   case 6:
	      ((**outArg))._u.b._length =
		 *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      ((**outArg))._u.b._maximum = ((**outArg))._u.b._length;
	      ((**outArg))._u.b._buffer =
		 CORBA_sequence_CORBA_string_allocbuf(((**outArg))._u.b.
						      _length);
	      ((**outArg))._u.b._release = CORBA_TRUE;
	      for (_ORBIT_tmpvar_74 = 0;
		   _ORBIT_tmpvar_74 < ((**outArg))._u.b._length;
		   _ORBIT_tmpvar_74++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 _ORBIT_tmpvar_76 = *((CORBA_unsigned_long *) _ORBIT_curptr);
		 _ORBIT_curptr += 4;
		 ((**outArg))._u.b._buffer[_ORBIT_tmpvar_74] =
		    CORBA_string_alloc(_ORBIT_tmpvar_76);
		 memcpy(((**outArg))._u.b._buffer[_ORBIT_tmpvar_74],
			_ORBIT_curptr,
			sizeof(((**outArg))._u.b.
			       _buffer[_ORBIT_tmpvar_74][_ORBIT_tmpvar_75]) *
			_ORBIT_tmpvar_76);
		 _ORBIT_curptr +=
		    sizeof(((**outArg))._u.b.
			   _buffer[_ORBIT_tmpvar_74][_ORBIT_tmpvar_75]) *
		    _ORBIT_tmpvar_76;
	      }

	      break;
	   case 7:
	      ((**outArg))._u.c._d = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      switch (((**outArg))._u.c._d) {
		case 'a':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		   ((**outArg))._u.c._u.x = *((CORBA_long *) _ORBIT_curptr);
		   break;
		case 'b':
		   ((**outArg))._u.c._u.y = *((CORBA_char *) _ORBIT_curptr);
		   break;
		case 'c':
		case 'd':
		   ((**outArg))._u.c._u.z =
		      *((CORBA_boolean *) _ORBIT_curptr);
		   break;
		case 'e':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
		   memcpy(&(((**outArg))._u.c._u.v), _ORBIT_curptr,
			  sizeof(((**outArg))._u.c._u.v));
		   break;
		default:
		   break;
	      }
	      break;
	   case 8:
	      for (_ORBIT_tmpvar_77 = 0; _ORBIT_tmpvar_77 < 2;
		   _ORBIT_tmpvar_77++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 _ORBIT_tmpvar_79 = *((CORBA_unsigned_long *) _ORBIT_curptr);
		 _ORBIT_curptr += 4;
		 ((**outArg))._u.d[_ORBIT_tmpvar_77] =
		    CORBA_string_alloc(_ORBIT_tmpvar_79);
		 memcpy(((**outArg))._u.d[_ORBIT_tmpvar_77], _ORBIT_curptr,
			sizeof(((**outArg))._u.
			       d[_ORBIT_tmpvar_77][_ORBIT_tmpvar_78]) *
			_ORBIT_tmpvar_79);
		 _ORBIT_curptr +=
		    sizeof(((**outArg))._u.
			   d[_ORBIT_tmpvar_77][_ORBIT_tmpvar_78]) *
		    _ORBIT_tmpvar_79;
	      }

	      break;
	 }
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
CORBA_any *
test_AnyServer_opAnyStrSeq(test_AnyServer _obj, CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_any *_ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_AnyServer__classid) {
      _ORBIT_retval =
	 ((POA_test_AnyServer__epv *) _obj->vepv[test_AnyServer__classid])->
	 opAnyStrSeq(_obj->servant, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[12];
      }
      _ORBIT_operation_name_data =
      {
      12, "opAnyStrSeq"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 16 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = CORBA_any__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*_ORBIT_retval)),
			     CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*_ORBIT_retval)),
			     CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
CORBA_any *
test_AnyServer_opAnyLong(test_AnyServer _obj, const CORBA_any * inArg,
			 CORBA_any * inoutArg, CORBA_any ** outArg,
			 CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_any *_ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_AnyServer__classid) {
      _ORBIT_retval =
	 ((POA_test_AnyServer__epv *) _obj->vepv[test_AnyServer__classid])->
	 opAnyLong(_obj->servant, inArg, inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[10];
      }
      _ORBIT_operation_name_data =
      {
      10, "opAnyLong"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 14 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      ORBit_marshal_any(_ORBIT_send_buffer, &((*inArg)));
      ORBit_marshal_any(_ORBIT_send_buffer, &((*inoutArg)));
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   if (CORBA_any_get_release(&(*inoutArg)))
      CORBA_free((*inoutArg)._value);
   CORBA_Object_release((CORBA_Object) (*inoutArg)._type, ev);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = CORBA_any__alloc();
      *outArg = CORBA_any__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*_ORBIT_retval)),
			     CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*inoutArg)), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &(((**outArg))), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*_ORBIT_retval)),
			     CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*inoutArg)), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &(((**outArg))), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
CORBA_any *
test_AnyServer_opAnyString(test_AnyServer _obj, const CORBA_any * inArg,
			   CORBA_any * inoutArg, CORBA_any ** outArg,
			   CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_any *_ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_AnyServer__classid) {
      _ORBIT_retval =
	 ((POA_test_AnyServer__epv *) _obj->vepv[test_AnyServer__classid])->
	 opAnyString(_obj->servant, inArg, inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[12];
      }
      _ORBIT_operation_name_data =
      {
      12, "opAnyString"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 16 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      ORBit_marshal_any(_ORBIT_send_buffer, &((*inArg)));
      ORBit_marshal_any(_ORBIT_send_buffer, &((*inoutArg)));
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   if (CORBA_any_get_release(&(*inoutArg)))
      CORBA_free((*inoutArg)._value);
   CORBA_Object_release((CORBA_Object) (*inoutArg)._type, ev);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = CORBA_any__alloc();
      *outArg = CORBA_any__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*_ORBIT_retval)),
			     CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*inoutArg)), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &(((**outArg))), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*_ORBIT_retval)),
			     CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*inoutArg)), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &(((**outArg))), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
CORBA_any *
test_AnyServer_opAnyStruct(test_AnyServer _obj, const CORBA_any * inArg,
			   CORBA_any * inoutArg, CORBA_any ** outArg,
			   CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_any *_ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_AnyServer__classid) {
      _ORBIT_retval =
	 ((POA_test_AnyServer__epv *) _obj->vepv[test_AnyServer__classid])->
	 opAnyStruct(_obj->servant, inArg, inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[12];
      }
      _ORBIT_operation_name_data =
      {
      12, "opAnyStruct"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 16 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      ORBit_marshal_any(_ORBIT_send_buffer, &((*inArg)));
      ORBit_marshal_any(_ORBIT_send_buffer, &((*inoutArg)));
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   if (CORBA_any_get_release(&(*inoutArg)))
      CORBA_free((*inoutArg)._value);
   CORBA_Object_release((CORBA_Object) (*inoutArg)._type, ev);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_retval = CORBA_any__alloc();
      *outArg = CORBA_any__alloc();
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*_ORBIT_retval)),
			     CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*inoutArg)), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &(((**outArg))), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*_ORBIT_retval)),
			     CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &((*inoutArg)), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_demarshal_any(_ORBIT_recv_buffer, &(((**outArg))), CORBA_TRUE,
			     GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
			     connection->orb_data);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
CORBA_TypeCode
test_AnyServer_opTypeCode(test_AnyServer _obj, const CORBA_TypeCode inArg,
			  CORBA_TypeCode * inoutArg, CORBA_TypeCode * outArg,
			  CORBA_Environment * ev)
{
   register GIOP_unsigned_long _ORBIT_request_id,
    _ORBIT_system_exception_minor;
   register CORBA_completion_status _ORBIT_completion_status;
   register GIOPSendBuffer *_ORBIT_send_buffer;
   register GIOPRecvBuffer *_ORBIT_recv_buffer;
   register GIOPConnection *_cnx;
   CORBA_TypeCode _ORBIT_retval;

   if (_obj->servant && _obj->vepv && test_AnyServer__classid) {
      _ORBIT_retval =
	 ((POA_test_AnyServer__epv *) _obj->vepv[test_AnyServer__classid])->
	 opTypeCode(_obj->servant, inArg, inoutArg, outArg, ev);
      return _ORBIT_retval;
   }
   if (0)
      return *(&_ORBIT_retval);
   _cnx = ORBit_object_get_connection(_obj);
 _ORBIT_retry_request:
   _ORBIT_send_buffer = NULL;
   _ORBIT_recv_buffer = NULL;
   _ORBIT_completion_status = CORBA_COMPLETED_NO;
   _ORBIT_request_id = GPOINTER_TO_UINT(alloca(0));
   {				/* marshalling */
      static const struct
      {
	 CORBA_unsigned_long len;
	 char opname[11];
      }
      _ORBIT_operation_name_data =
      {
      11, "opTypeCode"};
      static const struct iovec _ORBIT_operation_vec =
	 { (gpointer) & _ORBIT_operation_name_data, 15 };
      _ORBIT_send_buffer =
	 giop_send_request_buffer_use(_cnx, NULL, _ORBIT_request_id,
				      CORBA_TRUE,
				      &(_obj->active_profile->object_key_vec),
				      &_ORBIT_operation_vec,
				      &ORBit_default_principal_iovec);

      _ORBIT_system_exception_minor = ex_CORBA_COMM_FAILURE;
      if (!_ORBIT_send_buffer)
	 goto _ORBIT_system_exception;
      ORBit_encode_CORBA_TypeCode(inArg, _ORBIT_send_buffer);
      ORBit_encode_CORBA_TypeCode((*inoutArg), _ORBIT_send_buffer);
      giop_send_buffer_write(_ORBIT_send_buffer);
      _ORBIT_completion_status = CORBA_COMPLETED_MAYBE;
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      _ORBIT_send_buffer = NULL;
   }
   CORBA_Object_release((CORBA_Object) * inoutArg, ev);
   {				/* demarshalling */
      register guchar *_ORBIT_curptr;

      _ORBIT_recv_buffer =
	 giop_recv_reply_buffer_use_2(_cnx, _ORBIT_request_id, TRUE);
      if (!_ORBIT_recv_buffer)
	 goto _ORBIT_system_exception;
      _ORBIT_completion_status = CORBA_COMPLETED_YES;
      if (_ORBIT_recv_buffer->message.u.reply.reply_status !=
	  GIOP_NO_EXCEPTION)
	 goto _ORBIT_msg_exception;
      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_decode_CORBA_TypeCode(&_ORBIT_retval, _ORBIT_recv_buffer);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_decode_CORBA_TypeCode(&(*inoutArg), _ORBIT_recv_buffer);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_decode_CORBA_TypeCode(&(*outArg), _ORBIT_recv_buffer);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_decode_CORBA_TypeCode(&_ORBIT_retval, _ORBIT_recv_buffer);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_decode_CORBA_TypeCode(&(*inoutArg), _ORBIT_recv_buffer);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_decode_CORBA_TypeCode(&(*outArg), _ORBIT_recv_buffer);
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      return _ORBIT_retval;
    _ORBIT_system_exception:
      CORBA_exception_set_system(ev, _ORBIT_system_exception_minor,
				 _ORBIT_completion_status);
      giop_recv_buffer_unuse(_ORBIT_recv_buffer);
      giop_send_buffer_unuse(_ORBIT_send_buffer);
      return _ORBIT_retval;
    _ORBIT_msg_exception:
      if (_ORBIT_recv_buffer->message.u.reply.reply_status ==
	  GIOP_LOCATION_FORWARD) {
	 if (_obj->forward_locations != NULL)
	    ORBit_delete_profiles(_obj->forward_locations);
	 _obj->forward_locations = ORBit_demarshal_IOR(_ORBIT_recv_buffer);
	 _cnx = ORBit_object_get_forwarded_connection(_obj);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);

	 goto _ORBIT_retry_request;
      } else {
	 ORBit_handle_exception(_ORBIT_recv_buffer, ev, NULL, _obj->orb);
	 giop_recv_buffer_unuse(_ORBIT_recv_buffer);
	 return _ORBIT_retval;
      }
   }
}
