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

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

void
_ORBIT_skel_test_TestFactory_getBasicServer(POA_test_TestFactory *
					    _ORBIT_servant,
					    GIOPRecvBuffer *
					    _ORBIT_recv_buffer,
					    CORBA_Environment * ev,
					    test_BasicServer
					    (*_impl_getBasicServer)
					    (PortableServer_Servant _servant,
					     CORBA_Environment * ev))
{
   test_BasicServer _ORBIT_retval;

   _ORBIT_retval = _impl_getBasicServer(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_getStructServer(POA_test_TestFactory *
					     _ORBIT_servant,
					     GIOPRecvBuffer *
					     _ORBIT_recv_buffer,
					     CORBA_Environment * ev,
					     test_StructServer
					     (*_impl_getStructServer)
					     (PortableServer_Servant _servant,
					      CORBA_Environment * ev))
{
   test_StructServer _ORBIT_retval;

   _ORBIT_retval = _impl_getStructServer(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_getSequenceServer(POA_test_TestFactory *
					       _ORBIT_servant,
					       GIOPRecvBuffer *
					       _ORBIT_recv_buffer,
					       CORBA_Environment * ev,
					       test_SequenceServer
					       (*_impl_getSequenceServer)
					       (PortableServer_Servant
						_servant,
						CORBA_Environment * ev))
{
   test_SequenceServer _ORBIT_retval;

   _ORBIT_retval = _impl_getSequenceServer(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_getUnionServer(POA_test_TestFactory *
					    _ORBIT_servant,
					    GIOPRecvBuffer *
					    _ORBIT_recv_buffer,
					    CORBA_Environment * ev,
					    test_UnionServer
					    (*_impl_getUnionServer)
					    (PortableServer_Servant _servant,
					     CORBA_Environment * ev))
{
   test_UnionServer _ORBIT_retval;

   _ORBIT_retval = _impl_getUnionServer(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_getArrayServer(POA_test_TestFactory *
					    _ORBIT_servant,
					    GIOPRecvBuffer *
					    _ORBIT_recv_buffer,
					    CORBA_Environment * ev,
					    test_ArrayServer
					    (*_impl_getArrayServer)
					    (PortableServer_Servant _servant,
					     CORBA_Environment * ev))
{
   test_ArrayServer _ORBIT_retval;

   _ORBIT_retval = _impl_getArrayServer(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_getAnyServer(POA_test_TestFactory *
					  _ORBIT_servant,
					  GIOPRecvBuffer * _ORBIT_recv_buffer,
					  CORBA_Environment * ev,
					  test_AnyServer(*_impl_getAnyServer)
					  (PortableServer_Servant _servant,
					   CORBA_Environment * ev))
{
   test_AnyServer _ORBIT_retval;

   _ORBIT_retval = _impl_getAnyServer(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_getBaseServer(POA_test_TestFactory *
					   _ORBIT_servant,
					   GIOPRecvBuffer *
					   _ORBIT_recv_buffer,
					   CORBA_Environment * ev,
					   test_BaseServer
					   (*_impl_getBaseServer)
					   (PortableServer_Servant _servant,
					    CORBA_Environment * ev))
{
   test_BaseServer _ORBIT_retval;

   _ORBIT_retval = _impl_getBaseServer(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_getDerivedServer(POA_test_TestFactory *
					      _ORBIT_servant,
					      GIOPRecvBuffer *
					      _ORBIT_recv_buffer,
					      CORBA_Environment * ev,
					      test_DerivedServer
					      (*_impl_getDerivedServer)
					      (PortableServer_Servant
					       _servant,
					       CORBA_Environment * ev))
{
   test_DerivedServer _ORBIT_retval;

   _ORBIT_retval = _impl_getDerivedServer(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_getDerivedServerAsBaseServer(POA_test_TestFactory
							  * _ORBIT_servant,
							  GIOPRecvBuffer *
							  _ORBIT_recv_buffer,
							  CORBA_Environment *
							  ev,
							  test_BaseServer
							  (*_impl_getDerivedServerAsBaseServer)
							  (PortableServer_Servant
							   _servant,
							   CORBA_Environment *
							   ev))
{
   test_BaseServer _ORBIT_retval;

   _ORBIT_retval = _impl_getDerivedServerAsBaseServer(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_getDerivedServerAsB2(POA_test_TestFactory *
						  _ORBIT_servant,
						  GIOPRecvBuffer *
						  _ORBIT_recv_buffer,
						  CORBA_Environment * ev,
						  test_B2
						  (*_impl_getDerivedServerAsB2)
						  (PortableServer_Servant
						   _servant,
						   CORBA_Environment * ev))
{
   test_B2 _ORBIT_retval;

   _ORBIT_retval = _impl_getDerivedServerAsB2(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TestFactory_createTransientObj(POA_test_TestFactory *
						_ORBIT_servant,
						GIOPRecvBuffer *
						_ORBIT_recv_buffer,
						CORBA_Environment * ev,
						test_TransientObj
						(*_impl_createTransientObj)
						(PortableServer_Servant
						 _servant,
						 CORBA_Environment * ev))
{
   test_TransientObj _ORBIT_retval;

   _ORBIT_retval = _impl_createTransientObj(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_object(_ORBIT_send_buffer, _ORBIT_retval);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release(_ORBIT_retval, ev);
   }
}
void
_ORBIT_skel_test_TransientObj_remove(POA_test_TransientObj * _ORBIT_servant,
				     GIOPRecvBuffer * _ORBIT_recv_buffer,
				     CORBA_Environment * ev,
				     void (*_impl_remove)
				     (PortableServer_Servant _servant,
				      CORBA_Environment * ev))
{
   _impl_remove(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_StructServer_opFixed(POA_test_StructServer * _ORBIT_servant,
				      GIOPRecvBuffer * _ORBIT_recv_buffer,
				      CORBA_Environment * ev,
				      test_FixedLengthStruct(*_impl_opFixed)
				      (PortableServer_Servant _servant,
				       const test_FixedLengthStruct * inArg,
				       test_FixedLengthStruct * inoutArg,
				       test_FixedLengthStruct * outArg,
				       CORBA_Environment * ev))
{
   test_FixedLengthStruct _ORBIT_retval;
   test_FixedLengthStruct inArg;
   test_FixedLengthStruct inoutArg;
   test_FixedLengthStruct outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (inArg.a))) =
	    GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
	 _ORBIT_curptr += 2;
	 (*((guint16 *) & (inoutArg.a))) =
	    GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	 memcpy(&(inArg), _ORBIT_curptr, sizeof(inArg));
	 _ORBIT_curptr += sizeof(inArg);
	 memcpy(&(inoutArg), _ORBIT_curptr, sizeof(inoutArg));
      }
   }
   _ORBIT_retval =
      _impl_opFixed(_ORBIT_servant, &(inArg), &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 2);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_retval));
	       memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_retval));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(inoutArg),
					   sizeof(inoutArg));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(outArg),
					   sizeof(outArg));
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_StructServer_opVariable(POA_test_StructServer *
					 _ORBIT_servant,
					 GIOPRecvBuffer * _ORBIT_recv_buffer,
					 CORBA_Environment * ev,
					 test_VariableLengthStruct *
					 (*_impl_opVariable)
					 (PortableServer_Servant _servant,
					  const test_VariableLengthStruct *
					  inArg,
					  test_VariableLengthStruct *
					  inoutArg,
					  test_VariableLengthStruct ** outArg,
					  CORBA_Environment * ev))
{
   test_VariableLengthStruct *_ORBIT_retval;
   test_VariableLengthStruct inArg;
   test_VariableLengthStruct inoutArg;
   test_VariableLengthStruct *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_16;
      CORBA_unsigned_long _ORBIT_tmpvar_17;
      register CORBA_unsigned_long _ORBIT_tmpvar_18;
      CORBA_unsigned_long _ORBIT_tmpvar_19;

      _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_17))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 inArg.a = (void *) _ORBIT_curptr;
	 _ORBIT_curptr +=
	    sizeof(inArg.a[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_19))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 inoutArg.a = CORBA_string_alloc(_ORBIT_tmpvar_19);
	 memcpy(inoutArg.a, _ORBIT_curptr,
		sizeof(inoutArg.a[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19);
	 _ORBIT_curptr +=
	    sizeof(inoutArg.a[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19;
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_17 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inArg.a = (void *) _ORBIT_curptr;
	 _ORBIT_curptr +=
	    sizeof(inArg.a[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_19 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inoutArg.a = CORBA_string_alloc(_ORBIT_tmpvar_19);
	 memcpy(inoutArg.a, _ORBIT_curptr,
		sizeof(inoutArg.a[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19);
	 _ORBIT_curptr +=
	    sizeof(inoutArg.a[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19;
      }
   }
   _ORBIT_retval =
      _impl_opVariable(_ORBIT_servant, &(inArg), &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_4;
	    CORBA_unsigned_long _ORBIT_tmpvar_5;
	    register CORBA_unsigned_long _ORBIT_tmpvar_6;
	    CORBA_unsigned_long _ORBIT_tmpvar_7;
	    register CORBA_unsigned_long _ORBIT_tmpvar_8;
	    CORBA_unsigned_long _ORBIT_tmpvar_9;

	    _ORBIT_tmpvar_5 = strlen((*_ORBIT_retval).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));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   ((*_ORBIT_retval).a),
					   sizeof((*_ORBIT_retval).
						  a[_ORBIT_tmpvar_4]) *
					   _ORBIT_tmpvar_5);
	    _ORBIT_tmpvar_7 = 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_7));
	       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_7), sizeof(_ORBIT_tmpvar_7));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_tmpvar_7));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (inoutArg.a),
					   sizeof(inoutArg.
						  a[_ORBIT_tmpvar_6]) *
					   _ORBIT_tmpvar_7);
	    _ORBIT_tmpvar_9 = strlen((*outArg).a) + 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),
					   ((*outArg).a),
					   sizeof((*outArg).
						  a[_ORBIT_tmpvar_8]) *
					   _ORBIT_tmpvar_9);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      test_VariableLengthStruct__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_skel_test_StructServer_opCompound(POA_test_StructServer *
					 _ORBIT_servant,
					 GIOPRecvBuffer * _ORBIT_recv_buffer,
					 CORBA_Environment * ev,
					 test_CompoundStruct *
					 (*_impl_opCompound)
					 (PortableServer_Servant _servant,
					  const test_CompoundStruct * inArg,
					  test_CompoundStruct * inoutArg,
					  test_CompoundStruct ** outArg,
					  CORBA_Environment * ev))
{
   test_CompoundStruct *_ORBIT_retval;
   test_CompoundStruct inArg;
   test_CompoundStruct inoutArg;
   test_CompoundStruct *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_16;
      CORBA_unsigned_long _ORBIT_tmpvar_17;
      register CORBA_unsigned_long _ORBIT_tmpvar_18;
      CORBA_unsigned_long _ORBIT_tmpvar_19;

      _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_17))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 inArg.a.a = (void *) _ORBIT_curptr;
	 _ORBIT_curptr +=
	    sizeof(inArg.a.a[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_19))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 inoutArg.a.a = CORBA_string_alloc(_ORBIT_tmpvar_19);
	 memcpy(inoutArg.a.a, _ORBIT_curptr,
		sizeof(inoutArg.a.a[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19);
	 _ORBIT_curptr +=
	    sizeof(inoutArg.a.a[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19;
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_17 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inArg.a.a = (void *) _ORBIT_curptr;
	 _ORBIT_curptr +=
	    sizeof(inArg.a.a[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_19 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inoutArg.a.a = CORBA_string_alloc(_ORBIT_tmpvar_19);
	 memcpy(inoutArg.a.a, _ORBIT_curptr,
		sizeof(inoutArg.a.a[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19);
	 _ORBIT_curptr +=
	    sizeof(inoutArg.a.a[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19;
      }
   }
   _ORBIT_retval =
      _impl_opCompound(_ORBIT_servant, &(inArg), &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_4;
	    CORBA_unsigned_long _ORBIT_tmpvar_5;
	    register CORBA_unsigned_long _ORBIT_tmpvar_6;
	    CORBA_unsigned_long _ORBIT_tmpvar_7;
	    register CORBA_unsigned_long _ORBIT_tmpvar_8;
	    CORBA_unsigned_long _ORBIT_tmpvar_9;

	    _ORBIT_tmpvar_5 = strlen((*_ORBIT_retval).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));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   ((*_ORBIT_retval).a.a),
					   sizeof((*_ORBIT_retval).a.
						  a[_ORBIT_tmpvar_4]) *
					   _ORBIT_tmpvar_5);
	    _ORBIT_tmpvar_7 = 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_7));
	       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_7), sizeof(_ORBIT_tmpvar_7));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_tmpvar_7));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   (inoutArg.a.a),
					   sizeof(inoutArg.a.
						  a[_ORBIT_tmpvar_6]) *
					   _ORBIT_tmpvar_7);
	    _ORBIT_tmpvar_9 = strlen((*outArg).a.a) + 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),
					   ((*outArg).a.a),
					   sizeof((*outArg).a.
						  a[_ORBIT_tmpvar_8]) *
					   _ORBIT_tmpvar_9);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      test_CompoundStruct__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_skel_test_SequenceServer_opStrSeq(POA_test_SequenceServer *
					 _ORBIT_servant,
					 GIOPRecvBuffer * _ORBIT_recv_buffer,
					 CORBA_Environment * ev,
					 test_StrSeq *
					 (*_impl_opStrSeq)
					 (PortableServer_Servant _servant,
					  const test_StrSeq * inArg,
					  test_StrSeq * inoutArg,
					  test_StrSeq ** outArg,
					  CORBA_Environment * ev))
{
   test_StrSeq *_ORBIT_retval;
   test_StrSeq inArg = { 0, 0, NULL, CORBA_FALSE };
   test_StrSeq inoutArg = { 0, 0, NULL, CORBA_FALSE };
   test_StrSeq *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_24;
      register CORBA_unsigned_long _ORBIT_tmpvar_25;
      CORBA_unsigned_long _ORBIT_tmpvar_26;
      register CORBA_unsigned_long _ORBIT_tmpvar_27;
      register CORBA_unsigned_long _ORBIT_tmpvar_28;
      CORBA_unsigned_long _ORBIT_tmpvar_29;

      _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 *) & (inArg._length))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 inArg._buffer =
	    alloca(sizeof(inArg._buffer[_ORBIT_tmpvar_24]) * inArg._length);
	 inArg._release = CORBA_FALSE;
	 for (_ORBIT_tmpvar_24 = 0; _ORBIT_tmpvar_24 < inArg._length;
	      _ORBIT_tmpvar_24++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_26))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    inArg._buffer[_ORBIT_tmpvar_24] = (void *) _ORBIT_curptr;
	    _ORBIT_curptr +=
	       sizeof(inArg._buffer[_ORBIT_tmpvar_24][_ORBIT_tmpvar_25]) *
	       _ORBIT_tmpvar_26;
	 }

	 _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_27 = 0; _ORBIT_tmpvar_27 < inoutArg._length;
	      _ORBIT_tmpvar_27++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_29))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    inoutArg._buffer[_ORBIT_tmpvar_27] =
	       CORBA_string_alloc(_ORBIT_tmpvar_29);
	    memcpy(inoutArg._buffer[_ORBIT_tmpvar_27], _ORBIT_curptr,
		   sizeof(inoutArg.
			  _buffer[_ORBIT_tmpvar_27][_ORBIT_tmpvar_28]) *
		   _ORBIT_tmpvar_29);
	    _ORBIT_curptr +=
	       sizeof(inoutArg._buffer[_ORBIT_tmpvar_27][_ORBIT_tmpvar_28]) *
	       _ORBIT_tmpvar_29;
	 }

      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 inArg._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inArg._buffer =
	    alloca(sizeof(inArg._buffer[_ORBIT_tmpvar_24]) * inArg._length);
	 inArg._release = CORBA_FALSE;
	 for (_ORBIT_tmpvar_24 = 0; _ORBIT_tmpvar_24 < inArg._length;
	      _ORBIT_tmpvar_24++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_26 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    inArg._buffer[_ORBIT_tmpvar_24] = (void *) _ORBIT_curptr;
	    _ORBIT_curptr +=
	       sizeof(inArg._buffer[_ORBIT_tmpvar_24][_ORBIT_tmpvar_25]) *
	       _ORBIT_tmpvar_26;
	 }

	 _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_27 = 0; _ORBIT_tmpvar_27 < inoutArg._length;
	      _ORBIT_tmpvar_27++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_29 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    inoutArg._buffer[_ORBIT_tmpvar_27] =
	       CORBA_string_alloc(_ORBIT_tmpvar_29);
	    memcpy(inoutArg._buffer[_ORBIT_tmpvar_27], _ORBIT_curptr,
		   sizeof(inoutArg.
			  _buffer[_ORBIT_tmpvar_27][_ORBIT_tmpvar_28]) *
		   _ORBIT_tmpvar_29);
	    _ORBIT_curptr +=
	       sizeof(inoutArg._buffer[_ORBIT_tmpvar_27][_ORBIT_tmpvar_28]) *
	       _ORBIT_tmpvar_29;
	 }

      }
   }
   _ORBIT_retval =
      _impl_opStrSeq(_ORBIT_servant, &(inArg), &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_6;
	    register CORBA_unsigned_long _ORBIT_tmpvar_7;
	    CORBA_unsigned_long _ORBIT_tmpvar_8;
	    register 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;
	    register CORBA_unsigned_long _ORBIT_tmpvar_13;
	    CORBA_unsigned_long _ORBIT_tmpvar_14;

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

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

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

		  _ORBIT_t =
		     alloca(sizeof
			    ((*_ORBIT_retval).
			     _buffer[_ORBIT_tmpvar_6][_ORBIT_tmpvar_7]) *
			    _ORBIT_tmpvar_8);
		  memcpy(_ORBIT_t,
			 ((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_6]),
			 sizeof((*_ORBIT_retval).
				_buffer[_ORBIT_tmpvar_6][_ORBIT_tmpvar_7]) *
			 _ORBIT_tmpvar_8);
		  giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer),
						 (_ORBIT_t),
						 sizeof((*_ORBIT_retval).
							_buffer
							[_ORBIT_tmpvar_6]
							[_ORBIT_tmpvar_7]) *
						 _ORBIT_tmpvar_8);
	       }
	    }

	    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_9 = 0; _ORBIT_tmpvar_9 < inoutArg._length;
		 _ORBIT_tmpvar_9++) {
	       _ORBIT_tmpvar_11 =
		  strlen(inoutArg._buffer[_ORBIT_tmpvar_9]) + 1;
	       giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer), 4);
	       {
		  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));
	       }
	       {
		  guchar *_ORBIT_t;

		  _ORBIT_t =
		     alloca(sizeof
			    (inoutArg.
			     _buffer[_ORBIT_tmpvar_9][_ORBIT_tmpvar_10]) *
			    _ORBIT_tmpvar_11);
		  memcpy(_ORBIT_t, (inoutArg._buffer[_ORBIT_tmpvar_9]),
			 sizeof(inoutArg.
				_buffer[_ORBIT_tmpvar_9][_ORBIT_tmpvar_10]) *
			 _ORBIT_tmpvar_11);
		  giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer),
						 (_ORBIT_t),
						 sizeof(inoutArg.
							_buffer
							[_ORBIT_tmpvar_9]
							[_ORBIT_tmpvar_10]) *
						 _ORBIT_tmpvar_11);
	       }
	    }

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

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

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

		  _ORBIT_t =
		     alloca(sizeof
			    ((*outArg).
			     _buffer[_ORBIT_tmpvar_12][_ORBIT_tmpvar_13]) *
			    _ORBIT_tmpvar_14);
		  memcpy(_ORBIT_t, ((*outArg)._buffer[_ORBIT_tmpvar_12]),
			 sizeof((*outArg).
				_buffer[_ORBIT_tmpvar_12][_ORBIT_tmpvar_13]) *
			 _ORBIT_tmpvar_14);
		  giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer),
						 (_ORBIT_t),
						 sizeof((*outArg).
							_buffer
							[_ORBIT_tmpvar_12]
							[_ORBIT_tmpvar_13]) *
						 _ORBIT_tmpvar_14);
	       }
	    }

	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      test_StrSeq__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_skel_test_SequenceServer_opBoundedStructSeq(POA_test_SequenceServer *
						   _ORBIT_servant,
						   GIOPRecvBuffer *
						   _ORBIT_recv_buffer,
						   CORBA_Environment * ev,
						   test_BoundedStructSeq *
						   (*_impl_opBoundedStructSeq)
						   (PortableServer_Servant
						    _servant,
						    const
						    test_BoundedStructSeq *
						    inArg,
						    test_BoundedStructSeq *
						    inoutArg,
						    test_BoundedStructSeq **
						    outArg,
						    CORBA_Environment * ev))
{
   test_BoundedStructSeq *_ORBIT_retval;
   test_BoundedStructSeq inArg = { 0, 0, NULL, CORBA_FALSE };
   test_BoundedStructSeq inoutArg = { 0, 0, NULL, CORBA_FALSE };
   test_BoundedStructSeq *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_24;
      register CORBA_unsigned_long _ORBIT_tmpvar_25;
      CORBA_unsigned_long _ORBIT_tmpvar_26;
      register CORBA_unsigned_long _ORBIT_tmpvar_27;
      register CORBA_unsigned_long _ORBIT_tmpvar_28;
      CORBA_unsigned_long _ORBIT_tmpvar_29;

      _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 *) & (inArg._length))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 inArg._buffer =
	    alloca(sizeof(inArg._buffer[_ORBIT_tmpvar_24]) * inArg._length);
	 inArg._release = CORBA_FALSE;
	 for (_ORBIT_tmpvar_24 = 0; _ORBIT_tmpvar_24 < inArg._length;
	      _ORBIT_tmpvar_24++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_26))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    inArg._buffer[_ORBIT_tmpvar_24].a.a = (void *) _ORBIT_curptr;
	    _ORBIT_curptr +=
	       sizeof(inArg._buffer[_ORBIT_tmpvar_24].a.a[_ORBIT_tmpvar_25]) *
	       _ORBIT_tmpvar_26;
	 }

	 _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_27 = 0; _ORBIT_tmpvar_27 < inoutArg._length;
	      _ORBIT_tmpvar_27++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_29))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    inoutArg._buffer[_ORBIT_tmpvar_27].a.a =
	       CORBA_string_alloc(_ORBIT_tmpvar_29);
	    memcpy(inoutArg._buffer[_ORBIT_tmpvar_27].a.a, _ORBIT_curptr,
		   sizeof(inoutArg._buffer[_ORBIT_tmpvar_27].a.
			  a[_ORBIT_tmpvar_28]) * _ORBIT_tmpvar_29);
	    _ORBIT_curptr +=
	       sizeof(inoutArg._buffer[_ORBIT_tmpvar_27].a.
		      a[_ORBIT_tmpvar_28]) * _ORBIT_tmpvar_29;
	 }

      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 inArg._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inArg._buffer =
	    alloca(sizeof(inArg._buffer[_ORBIT_tmpvar_24]) * inArg._length);
	 inArg._release = CORBA_FALSE;
	 for (_ORBIT_tmpvar_24 = 0; _ORBIT_tmpvar_24 < inArg._length;
	      _ORBIT_tmpvar_24++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_26 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    inArg._buffer[_ORBIT_tmpvar_24].a.a = (void *) _ORBIT_curptr;
	    _ORBIT_curptr +=
	       sizeof(inArg._buffer[_ORBIT_tmpvar_24].a.a[_ORBIT_tmpvar_25]) *
	       _ORBIT_tmpvar_26;
	 }

	 _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_27 = 0; _ORBIT_tmpvar_27 < inoutArg._length;
	      _ORBIT_tmpvar_27++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_29 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    inoutArg._buffer[_ORBIT_tmpvar_27].a.a =
	       CORBA_string_alloc(_ORBIT_tmpvar_29);
	    memcpy(inoutArg._buffer[_ORBIT_tmpvar_27].a.a, _ORBIT_curptr,
		   sizeof(inoutArg._buffer[_ORBIT_tmpvar_27].a.
			  a[_ORBIT_tmpvar_28]) * _ORBIT_tmpvar_29);
	    _ORBIT_curptr +=
	       sizeof(inoutArg._buffer[_ORBIT_tmpvar_27].a.
		      a[_ORBIT_tmpvar_28]) * _ORBIT_tmpvar_29;
	 }

      }
   }
   _ORBIT_retval =
      _impl_opBoundedStructSeq(_ORBIT_servant, &(inArg), &(inoutArg),
			       &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_6;
	    register CORBA_unsigned_long _ORBIT_tmpvar_7;
	    CORBA_unsigned_long _ORBIT_tmpvar_8;
	    register 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;
	    register CORBA_unsigned_long _ORBIT_tmpvar_13;
	    CORBA_unsigned_long _ORBIT_tmpvar_14;

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

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

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

		  _ORBIT_t =
		     alloca(sizeof
			    ((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_6].a.
			     a[_ORBIT_tmpvar_7]) * _ORBIT_tmpvar_8);
		  memcpy(_ORBIT_t,
			 ((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_6].a.a),
			 sizeof((*_ORBIT_retval)._buffer[_ORBIT_tmpvar_6].a.
				a[_ORBIT_tmpvar_7]) * _ORBIT_tmpvar_8);
		  giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer),
						 (_ORBIT_t),
						 sizeof((*_ORBIT_retval).
							_buffer
							[_ORBIT_tmpvar_6].a.
							a[_ORBIT_tmpvar_7]) *
						 _ORBIT_tmpvar_8);
	       }
	    }

	    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_9 = 0; _ORBIT_tmpvar_9 < inoutArg._length;
		 _ORBIT_tmpvar_9++) {
	       _ORBIT_tmpvar_11 =
		  strlen(inoutArg._buffer[_ORBIT_tmpvar_9].a.a) + 1;
	       giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer), 4);
	       {
		  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));
	       }
	       {
		  guchar *_ORBIT_t;

		  _ORBIT_t =
		     alloca(sizeof
			    (inoutArg._buffer[_ORBIT_tmpvar_9].a.
			     a[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11);
		  memcpy(_ORBIT_t, (inoutArg._buffer[_ORBIT_tmpvar_9].a.a),
			 sizeof(inoutArg._buffer[_ORBIT_tmpvar_9].a.
				a[_ORBIT_tmpvar_10]) * _ORBIT_tmpvar_11);
		  giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer),
						 (_ORBIT_t),
						 sizeof(inoutArg.
							_buffer
							[_ORBIT_tmpvar_9].a.
							a[_ORBIT_tmpvar_10]) *
						 _ORBIT_tmpvar_11);
	       }
	    }

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

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

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

		  _ORBIT_t =
		     alloca(sizeof
			    ((*outArg)._buffer[_ORBIT_tmpvar_12].a.
			     a[_ORBIT_tmpvar_13]) * _ORBIT_tmpvar_14);
		  memcpy(_ORBIT_t, ((*outArg)._buffer[_ORBIT_tmpvar_12].a.a),
			 sizeof((*outArg)._buffer[_ORBIT_tmpvar_12].a.
				a[_ORBIT_tmpvar_13]) * _ORBIT_tmpvar_14);
		  giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer),
						 (_ORBIT_t),
						 sizeof((*outArg).
							_buffer
							[_ORBIT_tmpvar_12].a.
							a[_ORBIT_tmpvar_13]) *
						 _ORBIT_tmpvar_14);
	       }
	    }

	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      test_BoundedStructSeq__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_test_TestException_marshal(GIOPSendBuffer * _ORBIT_send_buffer,
				  CORBA_Environment * ev)
{
   register CORBA_unsigned_long _ORBIT_tmpvar_0;
   CORBA_unsigned_long _ORBIT_tmpvar_1;
   register CORBA_unsigned_long _ORBIT_tmpvar_2;
   test_TestException *_ORBIT_exdata = ev->_params;

   _ORBIT_tmpvar_1 = strlen((*_ORBIT_exdata).reason) + 1;
   giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				    4);
   giop_send_buffer_append_mem_indirect(GIOP_SEND_BUFFER(_ORBIT_send_buffer),
					&(_ORBIT_tmpvar_1),
					sizeof(_ORBIT_tmpvar_1));
   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				  ((*_ORBIT_exdata).reason),
				  sizeof((*_ORBIT_exdata).
					 reason[_ORBIT_tmpvar_0]) *
				  _ORBIT_tmpvar_1);
   giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				    4);
   giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER(_ORBIT_send_buffer),
				  &((*_ORBIT_exdata).number),
				  sizeof((*_ORBIT_exdata).number));
   giop_send_buffer_append_mem_indirect(GIOP_SEND_BUFFER(_ORBIT_send_buffer),
					&((*_ORBIT_exdata).aseq._length),
					sizeof((*_ORBIT_exdata).aseq.
					       _length));
   giop_send_buffer_append_mem_indirect(GIOP_SEND_BUFFER(_ORBIT_send_buffer),
					((*_ORBIT_exdata).aseq._buffer),
					sizeof((*_ORBIT_exdata).aseq.
					       _buffer[_ORBIT_tmpvar_2]) *
					(*_ORBIT_exdata).aseq._length);
   ORBit_marshal_object(_ORBIT_send_buffer, (*_ORBIT_exdata).factory);
}

void
_ORBIT_skel_test_ArrayServer_opLongArray(POA_test_ArrayServer *
					 _ORBIT_servant,
					 GIOPRecvBuffer * _ORBIT_recv_buffer,
					 CORBA_Environment * ev,
					 test_LongArray_slice *
					 (*_impl_opLongArray)
					 (PortableServer_Servant _servant,
					  const test_LongArray inArg,
					  test_LongArray inoutArg,
					  test_LongArray outArg,
					  CORBA_Environment * ev))
{
   test_LongArray_slice *_ORBIT_retval;
   test_LongArray inArg;
   test_LongArray inoutArg;
   test_LongArray outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_8;
      register CORBA_unsigned_long _ORBIT_tmpvar_9;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 for (_ORBIT_tmpvar_8 = 0; _ORBIT_tmpvar_8 < 2; _ORBIT_tmpvar_8++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (inArg[_ORBIT_tmpvar_8]))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	 }

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

      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 memcpy(inArg, _ORBIT_curptr, sizeof(inArg[_ORBIT_tmpvar_8]) * 2);
	 _ORBIT_curptr += sizeof(inArg[_ORBIT_tmpvar_8]) * 2;
	 memcpy(inoutArg, _ORBIT_curptr,
		sizeof(inoutArg[_ORBIT_tmpvar_9]) * 2);
      }
   }
   _ORBIT_retval =
      _impl_opLongArray(_ORBIT_servant, inArg, inoutArg, outArg, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_2;
	    register CORBA_unsigned_long _ORBIT_tmpvar_3;
	    register CORBA_unsigned_long _ORBIT_tmpvar_4;

	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   (_ORBIT_retval),
					   sizeof(_ORBIT_retval
						  [_ORBIT_tmpvar_2]) * 2);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (inoutArg),
					   sizeof(inoutArg[_ORBIT_tmpvar_3]) *
					   2);
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (outArg),
					   sizeof(outArg[_ORBIT_tmpvar_4]) *
					   2);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
   }
}
void
_ORBIT_skel_test_ArrayServer_opStrArray(POA_test_ArrayServer * _ORBIT_servant,
					GIOPRecvBuffer * _ORBIT_recv_buffer,
					CORBA_Environment * ev,
					test_StrArray_slice *
					(*_impl_opStrArray)
					(PortableServer_Servant _servant,
					 const test_StrArray inArg,
					 test_StrArray inoutArg,
					 test_StrArray_slice ** outArg,
					 CORBA_Environment * ev))
{
   test_StrArray_slice *_ORBIT_retval;
   test_StrArray inArg;
   test_StrArray inoutArg;
   test_StrArray_slice *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_24;
      register CORBA_unsigned_long _ORBIT_tmpvar_25;
      CORBA_unsigned_long _ORBIT_tmpvar_26;
      register CORBA_unsigned_long _ORBIT_tmpvar_27;
      register CORBA_unsigned_long _ORBIT_tmpvar_28;
      CORBA_unsigned_long _ORBIT_tmpvar_29;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 for (_ORBIT_tmpvar_24 = 0; _ORBIT_tmpvar_24 < 2; _ORBIT_tmpvar_24++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    (*((guint32 *) & (_ORBIT_tmpvar_26))) =
	       GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	    _ORBIT_curptr += 4;
	    inArg[_ORBIT_tmpvar_24] = (void *) _ORBIT_curptr;
	    _ORBIT_curptr +=
	       sizeof(inArg[_ORBIT_tmpvar_24][_ORBIT_tmpvar_25]) *
	       _ORBIT_tmpvar_26;
	 }

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

      } else {
	 for (_ORBIT_tmpvar_24 = 0; _ORBIT_tmpvar_24 < 2; _ORBIT_tmpvar_24++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_26 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    inArg[_ORBIT_tmpvar_24] = (void *) _ORBIT_curptr;
	    _ORBIT_curptr +=
	       sizeof(inArg[_ORBIT_tmpvar_24][_ORBIT_tmpvar_25]) *
	       _ORBIT_tmpvar_26;
	 }

	 for (_ORBIT_tmpvar_27 = 0; _ORBIT_tmpvar_27 < 2; _ORBIT_tmpvar_27++) {
	    _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	    _ORBIT_tmpvar_29 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	    _ORBIT_curptr += 4;
	    inoutArg[_ORBIT_tmpvar_27] = CORBA_string_alloc(_ORBIT_tmpvar_29);
	    memcpy(inoutArg[_ORBIT_tmpvar_27], _ORBIT_curptr,
		   sizeof(inoutArg[_ORBIT_tmpvar_27][_ORBIT_tmpvar_28]) *
		   _ORBIT_tmpvar_29);
	    _ORBIT_curptr +=
	       sizeof(inoutArg[_ORBIT_tmpvar_27][_ORBIT_tmpvar_28]) *
	       _ORBIT_tmpvar_29;
	 }

      }
   }
   _ORBIT_retval =
      _impl_opStrArray(_ORBIT_servant, inArg, inoutArg, &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_6;
	    register CORBA_unsigned_long _ORBIT_tmpvar_7;
	    CORBA_unsigned_long _ORBIT_tmpvar_8;
	    register 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;
	    register CORBA_unsigned_long _ORBIT_tmpvar_13;
	    CORBA_unsigned_long _ORBIT_tmpvar_14;

	    for (_ORBIT_tmpvar_6 = 0; _ORBIT_tmpvar_6 < 2; _ORBIT_tmpvar_6++) {
	       _ORBIT_tmpvar_8 = strlen(_ORBIT_retval[_ORBIT_tmpvar_6]) + 1;
	       giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer), 4);
	       {
		  guchar *_ORBIT_t;

		  _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_8));
		  memcpy(_ORBIT_t, &(_ORBIT_tmpvar_8),
			 sizeof(_ORBIT_tmpvar_8));
		  giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer),
						 (_ORBIT_t),
						 sizeof(_ORBIT_tmpvar_8));
	       }
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_retval
					       [_ORBIT_tmpvar_6]),
					      sizeof(_ORBIT_retval
						     [_ORBIT_tmpvar_6]
						     [_ORBIT_tmpvar_7]) *
					      _ORBIT_tmpvar_8);
	    }

	    for (_ORBIT_tmpvar_9 = 0; _ORBIT_tmpvar_9 < 2; _ORBIT_tmpvar_9++) {
	       _ORBIT_tmpvar_11 = strlen(inoutArg[_ORBIT_tmpvar_9]) + 1;
	       giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer), 4);
	       {
		  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[_ORBIT_tmpvar_9]),
					      sizeof(inoutArg[_ORBIT_tmpvar_9]
						     [_ORBIT_tmpvar_10]) *
					      _ORBIT_tmpvar_11);
	    }

	    for (_ORBIT_tmpvar_12 = 0; _ORBIT_tmpvar_12 < 2;
		 _ORBIT_tmpvar_12++) {
	       _ORBIT_tmpvar_14 = strlen(outArg[_ORBIT_tmpvar_12]) + 1;
	       giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer), 4);
	       {
		  guchar *_ORBIT_t;

		  _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_14));
		  memcpy(_ORBIT_t, &(_ORBIT_tmpvar_14),
			 sizeof(_ORBIT_tmpvar_14));
		  giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						 (_ORBIT_send_buffer),
						 (_ORBIT_t),
						 sizeof(_ORBIT_tmpvar_14));
	       }
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (outArg[_ORBIT_tmpvar_12]),
					      sizeof(outArg[_ORBIT_tmpvar_12]
						     [_ORBIT_tmpvar_13]) *
					      _ORBIT_tmpvar_14);
	    }

	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      test_StrArray__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_skel_test_BasicServer__get_foo(POA_test_BasicServer * _ORBIT_servant,
				      GIOPRecvBuffer * _ORBIT_recv_buffer,
				      CORBA_Environment * ev,
				      CORBA_char *
				      (*_impl__get_foo)
				      (PortableServer_Servant _servant,
				       CORBA_Environment * ev))
{
   CORBA_char *_ORBIT_retval;

   _ORBIT_retval = _impl__get_foo(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_0;
	    CORBA_unsigned_long _ORBIT_tmpvar_1;

	    _ORBIT_tmpvar_1 = strlen(_ORBIT_retval) + 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),
					   (_ORBIT_retval),
					   sizeof(_ORBIT_retval
						  [_ORBIT_tmpvar_0]) *
					   _ORBIT_tmpvar_1);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
   }
}
void
_ORBIT_skel_test_BasicServer__set_foo(POA_test_BasicServer * _ORBIT_servant,
				      GIOPRecvBuffer * _ORBIT_recv_buffer,
				      CORBA_Environment * ev,
				      void (*_impl__set_foo)
				      (PortableServer_Servant _servant,
				       const CORBA_char * value,
				       CORBA_Environment * ev))
{
   CORBA_char *value;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _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;
	 value = (void *) _ORBIT_curptr;
	 _ORBIT_curptr += sizeof(value[_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;
	 value = (void *) _ORBIT_curptr;
	 _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _impl__set_foo(_ORBIT_servant, value, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_BasicServer__get_bah(POA_test_BasicServer * _ORBIT_servant,
				      GIOPRecvBuffer * _ORBIT_recv_buffer,
				      CORBA_Environment * ev,
				      CORBA_long(*_impl__get_bah)
				      (PortableServer_Servant _servant,
				       CORBA_Environment * ev))
{
   CORBA_long _ORBIT_retval;

   _ORBIT_retval = _impl__get_bah(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_retval));
	       memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_retval));
	    }
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_BasicServer_opString(POA_test_BasicServer * _ORBIT_servant,
				      GIOPRecvBuffer * _ORBIT_recv_buffer,
				      CORBA_Environment * ev,
				      CORBA_char *
				      (*_impl_opString)
				      (PortableServer_Servant _servant,
				       const CORBA_char * inArg,
				       CORBA_char ** inoutArg,
				       CORBA_char ** outArg,
				       CORBA_Environment * ev))
{
   CORBA_char *_ORBIT_retval;
   CORBA_char *inArg;
   CORBA_char *inoutArg;
   CORBA_char *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_16;
      CORBA_unsigned_long _ORBIT_tmpvar_17;
      register CORBA_unsigned_long _ORBIT_tmpvar_18;
      CORBA_unsigned_long _ORBIT_tmpvar_19;

      _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_17))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 inArg = (void *) _ORBIT_curptr;
	 _ORBIT_curptr += sizeof(inArg[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 (*((guint32 *) & (_ORBIT_tmpvar_19))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 inoutArg = CORBA_string_alloc(_ORBIT_tmpvar_19);
	 memcpy(inoutArg, _ORBIT_curptr,
		sizeof(inoutArg[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19);
	 _ORBIT_curptr +=
	    sizeof(inoutArg[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19;
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_17 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inArg = (void *) _ORBIT_curptr;
	 _ORBIT_curptr += sizeof(inArg[_ORBIT_tmpvar_16]) * _ORBIT_tmpvar_17;
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 _ORBIT_tmpvar_19 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inoutArg = CORBA_string_alloc(_ORBIT_tmpvar_19);
	 memcpy(inoutArg, _ORBIT_curptr,
		sizeof(inoutArg[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19);
	 _ORBIT_curptr +=
	    sizeof(inoutArg[_ORBIT_tmpvar_18]) * _ORBIT_tmpvar_19;
      }
   }
   _ORBIT_retval =
      _impl_opString(_ORBIT_servant, inArg, &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_4;
	    CORBA_unsigned_long _ORBIT_tmpvar_5;
	    register CORBA_unsigned_long _ORBIT_tmpvar_6;
	    CORBA_unsigned_long _ORBIT_tmpvar_7;
	    register CORBA_unsigned_long _ORBIT_tmpvar_8;
	    CORBA_unsigned_long _ORBIT_tmpvar_9;

	    _ORBIT_tmpvar_5 = strlen(_ORBIT_retval) + 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),
					   (_ORBIT_retval),
					   sizeof(_ORBIT_retval
						  [_ORBIT_tmpvar_4]) *
					   _ORBIT_tmpvar_5);
	    _ORBIT_tmpvar_7 = strlen(inoutArg) + 1;
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_7));
	       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_7), sizeof(_ORBIT_tmpvar_7));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_tmpvar_7));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), (inoutArg),
					   sizeof(inoutArg[_ORBIT_tmpvar_6]) *
					   _ORBIT_tmpvar_7);
	    _ORBIT_tmpvar_9 = strlen(outArg) + 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), (outArg),
					   sizeof(outArg[_ORBIT_tmpvar_8]) *
					   _ORBIT_tmpvar_9);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      CORBA_string__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_skel_test_BasicServer_opLong(POA_test_BasicServer * _ORBIT_servant,
				    GIOPRecvBuffer * _ORBIT_recv_buffer,
				    CORBA_Environment * ev,
				    CORBA_long(*_impl_opLong)
				    (PortableServer_Servant _servant,
				     const CORBA_long inArg,
				     CORBA_long * inoutArg,
				     CORBA_long * outArg,
				     CORBA_Environment * ev))
{
   CORBA_long _ORBIT_retval;
   CORBA_long inArg;
   CORBA_long inoutArg;
   CORBA_long outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (inArg))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (inoutArg))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 inArg = *((CORBA_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inoutArg = *((CORBA_long *) _ORBIT_curptr);
      }
   }
   _ORBIT_retval =
      _impl_opLong(_ORBIT_servant, inArg, &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_retval));
	       memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_retval));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(inoutArg),
					   sizeof(inoutArg));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(outArg),
					   sizeof(outArg));
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_BasicServer_opEnum(POA_test_BasicServer * _ORBIT_servant,
				    GIOPRecvBuffer * _ORBIT_recv_buffer,
				    CORBA_Environment * ev,
				    test_AnEnum(*_impl_opEnum)
				    (PortableServer_Servant _servant,
				     const test_AnEnum inArg,
				     test_AnEnum * inoutArg,
				     test_AnEnum * outArg,
				     CORBA_Environment * ev))
{
   test_AnEnum _ORBIT_retval;
   test_AnEnum inArg;
   test_AnEnum inoutArg;
   test_AnEnum outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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 *) & (inArg))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 (*((guint32 *) & (inoutArg))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 inArg = *((test_AnEnum *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 inoutArg = *((test_AnEnum *) _ORBIT_curptr);
      }
   }
   _ORBIT_retval =
      _impl_opEnum(_ORBIT_servant, inArg, &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_retval));
	       memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_retval));
	    }
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(inoutArg),
					   sizeof(inoutArg));
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(outArg),
					   sizeof(outArg));
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_BasicServer_opException(POA_test_BasicServer *
					 _ORBIT_servant,
					 GIOPRecvBuffer * _ORBIT_recv_buffer,
					 CORBA_Environment * ev,
					 void (*_impl_opException)
					 (PortableServer_Servant _servant,
					  CORBA_Environment * ev))
{
   _impl_opException(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	 } else if (ev->_major == CORBA_USER_EXCEPTION) {
	    static const ORBit_exception_marshal_info _ORBIT_user_exceptions[]
	       =
	       { {(const CORBA_TypeCode) &TC_test_TestException_struct,
		  (gpointer) _ORBIT_test_TestException_marshal},
	       {CORBA_OBJECT_NIL, NULL} };
	    ORBit_send_user_exception(_ORBIT_send_buffer, ev,
				      _ORBIT_user_exceptions);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_BaseServer_opPolymorphic(POA_test_BaseServer *
					  _ORBIT_servant,
					  GIOPRecvBuffer * _ORBIT_recv_buffer,
					  CORBA_Environment * ev,
					  CORBA_long(*_impl_opPolymorphic)
					  (PortableServer_Servant _servant,
					   CORBA_Environment * ev))
{
   CORBA_long _ORBIT_retval;

   _ORBIT_retval = _impl_opPolymorphic(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
					     (_ORBIT_send_buffer), 4);
	    {
	       guchar *_ORBIT_t;

	       _ORBIT_t = alloca(sizeof(_ORBIT_retval));
	       memcpy(_ORBIT_t, &(_ORBIT_retval), sizeof(_ORBIT_retval));
	       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					      (_ORBIT_send_buffer),
					      (_ORBIT_t),
					      sizeof(_ORBIT_retval));
	    }
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_BaseServer__get_attribPolymorphic(POA_test_BaseServer *
						   _ORBIT_servant,
						   GIOPRecvBuffer *
						   _ORBIT_recv_buffer,
						   CORBA_Environment * ev,
						   CORBA_char *
						   (*_impl__get_attribPolymorphic)
						   (PortableServer_Servant
						    _servant,
						    CORBA_Environment * ev))
{
   CORBA_char *_ORBIT_retval;

   _ORBIT_retval = _impl__get_attribPolymorphic(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_0;
	    CORBA_unsigned_long _ORBIT_tmpvar_1;

	    _ORBIT_tmpvar_1 = strlen(_ORBIT_retval) + 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),
					   (_ORBIT_retval),
					   sizeof(_ORBIT_retval
						  [_ORBIT_tmpvar_0]) *
					   _ORBIT_tmpvar_1);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
   }
}
void
_ORBIT_skel_test_BaseServer__set_attribPolymorphic(POA_test_BaseServer *
						   _ORBIT_servant,
						   GIOPRecvBuffer *
						   _ORBIT_recv_buffer,
						   CORBA_Environment * ev,
						   void
						   (*_impl__set_attribPolymorphic)
						   (PortableServer_Servant
						    _servant,
						    const CORBA_char * value,
						    CORBA_Environment * ev))
{
   CORBA_char *value;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_2;
      CORBA_unsigned_long _ORBIT_tmpvar_3;

      _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;
	 value = (void *) _ORBIT_curptr;
	 _ORBIT_curptr += sizeof(value[_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;
	 value = (void *) _ORBIT_curptr;
	 _ORBIT_curptr += sizeof(value[_ORBIT_tmpvar_2]) * _ORBIT_tmpvar_3;
      }
   }
   _impl__set_attribPolymorphic(_ORBIT_servant, value, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_UnionServer_opFixed(POA_test_UnionServer * _ORBIT_servant,
				     GIOPRecvBuffer * _ORBIT_recv_buffer,
				     CORBA_Environment * ev,
				     test_FixedLengthUnion(*_impl_opFixed)
				     (PortableServer_Servant _servant,
				      const test_FixedLengthUnion * inArg,
				      test_FixedLengthUnion * inoutArg,
				      test_FixedLengthUnion * outArg,
				      CORBA_Environment * ev))
{
   test_FixedLengthUnion _ORBIT_retval;
   test_FixedLengthUnion inArg;
   test_FixedLengthUnion inoutArg;
   test_FixedLengthUnion outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      if (giop_msg_conversion_needed(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer))) {
	 inArg._d = *((CORBA_char *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 switch (inArg._d) {
	   case 'a':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	      (*((guint32 *) & (inArg._u.x))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      break;
	   case 'b':
	      inArg._u.y = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'c':
	   case 'd':
	      inArg._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      (*((guint16 *) & (inArg._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));
	      break;
	   case 'b':
	      inoutArg._u.y = *((CORBA_char *) _ORBIT_curptr);
	      break;
	   case 'c':
	   case 'd':
	      inoutArg._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      (*((guint16 *) & (inoutArg._u.v.a))) =
		 GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
	      break;
	   default:
	      break;
	 }
      } else {
	 inArg._d = *((CORBA_char *) _ORBIT_curptr);
	 _ORBIT_curptr += 1;
	 switch (inArg._d) {
	   case 'a':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	      inArg._u.x = *((CORBA_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      break;
	   case 'b':
	      inArg._u.y = *((CORBA_char *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'c':
	   case 'd':
	      inArg._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      memcpy(&(inArg._u.v), _ORBIT_curptr, sizeof(inArg._u.v));
	      _ORBIT_curptr += sizeof(inArg._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);
	      break;
	   case 'b':
	      inoutArg._u.y = *((CORBA_char *) _ORBIT_curptr);
	      break;
	   case 'c':
	   case 'd':
	      inoutArg._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      break;
	   case 'e':
	      _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
	      memcpy(&(inoutArg._u.v), _ORBIT_curptr, sizeof(inoutArg._u.v));
	      break;
	   default:
	      break;
	 }
      }
   }
   _ORBIT_retval =
      _impl_opFixed(_ORBIT_servant, &(inArg), &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer),
					   &(_ORBIT_retval._d),
					   sizeof(_ORBIT_retval._d));
	    switch (_ORBIT_retval._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),
						&(_ORBIT_retval._u.x),
						sizeof(_ORBIT_retval._u.x));
		 break;
	      case 'b':
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						&(_ORBIT_retval._u.y),
						sizeof(_ORBIT_retval._u.y));
		 break;
	      case 'c':
	      case 'd':
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						&(_ORBIT_retval._u.z),
						sizeof(_ORBIT_retval._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),
						&(_ORBIT_retval._u.v),
						sizeof(_ORBIT_retval._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_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
					   (_ORBIT_send_buffer), &(outArg._d),
					   sizeof(outArg._d));
	    switch (outArg._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),
						&(outArg._u.x),
						sizeof(outArg._u.x));
		 break;
	      case 'b':
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						&(outArg._u.y),
						sizeof(outArg._u.y));
		 break;
	      case 'c':
	      case 'd':
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						&(outArg._u.z),
						sizeof(outArg._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),
						&(outArg._u.v),
						sizeof(outArg._u.v));
		 break;
	      default:
		 break;
	    }
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
   }
}
void
_ORBIT_skel_test_UnionServer_opVariable(POA_test_UnionServer * _ORBIT_servant,
					GIOPRecvBuffer * _ORBIT_recv_buffer,
					CORBA_Environment * ev,
					test_VariableLengthUnion *
					(*_impl_opVariable)
					(PortableServer_Servant _servant,
					 const test_VariableLengthUnion *
					 inArg,
					 test_VariableLengthUnion * inoutArg,
					 test_VariableLengthUnion ** outArg,
					 CORBA_Environment * ev))
{
   test_VariableLengthUnion *_ORBIT_retval;
   test_VariableLengthUnion inArg;
   test_VariableLengthUnion inoutArg;
   test_VariableLengthUnion *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;
      register CORBA_unsigned_long _ORBIT_tmpvar_80;
      CORBA_unsigned_long _ORBIT_tmpvar_81;
      register CORBA_unsigned_long _ORBIT_tmpvar_82;
      CORBA_unsigned_long _ORBIT_tmpvar_83;
      register CORBA_unsigned_long _ORBIT_tmpvar_84;
      register CORBA_unsigned_long _ORBIT_tmpvar_85;
      CORBA_unsigned_long _ORBIT_tmpvar_86;
      register CORBA_unsigned_long _ORBIT_tmpvar_87;
      register CORBA_unsigned_long _ORBIT_tmpvar_88;
      CORBA_unsigned_long _ORBIT_tmpvar_89;
      register CORBA_unsigned_long _ORBIT_tmpvar_90;
      CORBA_unsigned_long _ORBIT_tmpvar_91;
      register CORBA_unsigned_long _ORBIT_tmpvar_92;
      CORBA_unsigned_long _ORBIT_tmpvar_93;
      register CORBA_unsigned_long _ORBIT_tmpvar_94;
      register CORBA_unsigned_long _ORBIT_tmpvar_95;
      CORBA_unsigned_long _ORBIT_tmpvar_96;
      register CORBA_unsigned_long _ORBIT_tmpvar_97;
      register CORBA_unsigned_long _ORBIT_tmpvar_98;
      CORBA_unsigned_long _ORBIT_tmpvar_99;

      _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 *) & (inArg._d))) =
	    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	 _ORBIT_curptr += 4;
	 switch (inArg._d) {
	   case 1:
	      (*((guint32 *) & (inArg._u.x))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      break;
	   default:
	      (*((guint32 *) & (inArg._u.w))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      break;
	   case 2:
	      (*((guint32 *) & (_ORBIT_tmpvar_81))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      inArg._u.y = (void *) _ORBIT_curptr;
	      _ORBIT_curptr +=
		 sizeof(inArg._u.y[_ORBIT_tmpvar_80]) * _ORBIT_tmpvar_81;
	      break;
	   case 3:
	   case 4:
	      inArg._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 5:
	      (*((guint32 *) & (_ORBIT_tmpvar_83))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      inArg._u.a.a = (void *) _ORBIT_curptr;
	      _ORBIT_curptr +=
		 sizeof(inArg._u.a.a[_ORBIT_tmpvar_82]) * _ORBIT_tmpvar_83;
	      break;
	   case 6:
	      (*((guint32 *) & (inArg._u.b._length))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      inArg._u.b._buffer =
		 alloca(sizeof(inArg._u.b._buffer[_ORBIT_tmpvar_84]) *
			inArg._u.b._length);
	      inArg._u.b._release = CORBA_FALSE;
	      for (_ORBIT_tmpvar_84 = 0;
		   _ORBIT_tmpvar_84 < inArg._u.b._length;
		   _ORBIT_tmpvar_84++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 (*((guint32 *) & (_ORBIT_tmpvar_86))) =
		    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		 _ORBIT_curptr += 4;
		 inArg._u.b._buffer[_ORBIT_tmpvar_84] =
		    (void *) _ORBIT_curptr;
		 _ORBIT_curptr +=
		    sizeof(inArg._u.b.
			   _buffer[_ORBIT_tmpvar_84][_ORBIT_tmpvar_85]) *
		    _ORBIT_tmpvar_86;
	      }

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

	      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));
	      break;
	   default:
	      (*((guint32 *) & (inoutArg._u.w))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      break;
	   case 2:
	      (*((guint32 *) & (_ORBIT_tmpvar_91))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      inoutArg._u.y = CORBA_string_alloc(_ORBIT_tmpvar_91);
	      memcpy(inoutArg._u.y, _ORBIT_curptr,
		     sizeof(inoutArg._u.y[_ORBIT_tmpvar_90]) *
		     _ORBIT_tmpvar_91);
	      _ORBIT_curptr +=
		 sizeof(inoutArg._u.y[_ORBIT_tmpvar_90]) * _ORBIT_tmpvar_91;
	      break;
	   case 3:
	   case 4:
	      inoutArg._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      break;
	   case 5:
	      (*((guint32 *) & (_ORBIT_tmpvar_93))) =
		 GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
	      _ORBIT_curptr += 4;
	      inoutArg._u.a.a = CORBA_string_alloc(_ORBIT_tmpvar_93);
	      memcpy(inoutArg._u.a.a, _ORBIT_curptr,
		     sizeof(inoutArg._u.a.a[_ORBIT_tmpvar_92]) *
		     _ORBIT_tmpvar_93);
	      _ORBIT_curptr +=
		 sizeof(inoutArg._u.a.a[_ORBIT_tmpvar_92]) * _ORBIT_tmpvar_93;
	      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_94 = 0;
		   _ORBIT_tmpvar_94 < inoutArg._u.b._length;
		   _ORBIT_tmpvar_94++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 (*((guint32 *) & (_ORBIT_tmpvar_96))) =
		    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		 _ORBIT_curptr += 4;
		 inoutArg._u.b._buffer[_ORBIT_tmpvar_94] =
		    CORBA_string_alloc(_ORBIT_tmpvar_96);
		 memcpy(inoutArg._u.b._buffer[_ORBIT_tmpvar_94],
			_ORBIT_curptr,
			sizeof(inoutArg._u.b.
			       _buffer[_ORBIT_tmpvar_94][_ORBIT_tmpvar_95]) *
			_ORBIT_tmpvar_96);
		 _ORBIT_curptr +=
		    sizeof(inoutArg._u.b.
			   _buffer[_ORBIT_tmpvar_94][_ORBIT_tmpvar_95]) *
		    _ORBIT_tmpvar_96;
	      }

	      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));
		   break;
		case 'b':
		   inoutArg._u.c._u.y = *((CORBA_char *) _ORBIT_curptr);
		   break;
		case 'c':
		case 'd':
		   inoutArg._u.c._u.z = *((CORBA_boolean *) _ORBIT_curptr);
		   break;
		case 'e':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
		   (*((guint16 *) & (inoutArg._u.c._u.v.a))) =
		      GUINT16_SWAP_LE_BE(*((guint16 *) _ORBIT_curptr));
		   break;
		default:
		   break;
	      }
	      break;
	   case 8:
	      for (_ORBIT_tmpvar_97 = 0; _ORBIT_tmpvar_97 < 2;
		   _ORBIT_tmpvar_97++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 (*((guint32 *) & (_ORBIT_tmpvar_99))) =
		    GUINT32_SWAP_LE_BE(*((guint32 *) _ORBIT_curptr));
		 _ORBIT_curptr += 4;
		 inoutArg._u.d[_ORBIT_tmpvar_97] =
		    CORBA_string_alloc(_ORBIT_tmpvar_99);
		 memcpy(inoutArg._u.d[_ORBIT_tmpvar_97], _ORBIT_curptr,
			sizeof(inoutArg._u.
			       d[_ORBIT_tmpvar_97][_ORBIT_tmpvar_98]) *
			_ORBIT_tmpvar_99);
		 _ORBIT_curptr +=
		    sizeof(inoutArg._u.
			   d[_ORBIT_tmpvar_97][_ORBIT_tmpvar_98]) *
		    _ORBIT_tmpvar_99;
	      }

	      break;
	 }
      } else {
	 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
	 inArg._d = *((CORBA_long *) _ORBIT_curptr);
	 _ORBIT_curptr += 4;
	 switch (inArg._d) {
	   case 1:
	      inArg._u.x = *((CORBA_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      break;
	   default:
	      inArg._u.w = *((CORBA_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      break;
	   case 2:
	      _ORBIT_tmpvar_81 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      inArg._u.y = (void *) _ORBIT_curptr;
	      _ORBIT_curptr +=
		 sizeof(inArg._u.y[_ORBIT_tmpvar_80]) * _ORBIT_tmpvar_81;
	      break;
	   case 3:
	   case 4:
	      inArg._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      _ORBIT_curptr += 1;
	      break;
	   case 5:
	      _ORBIT_tmpvar_83 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      inArg._u.a.a = (void *) _ORBIT_curptr;
	      _ORBIT_curptr +=
		 sizeof(inArg._u.a.a[_ORBIT_tmpvar_82]) * _ORBIT_tmpvar_83;
	      break;
	   case 6:
	      inArg._u.b._length = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      inArg._u.b._buffer =
		 alloca(sizeof(inArg._u.b._buffer[_ORBIT_tmpvar_84]) *
			inArg._u.b._length);
	      inArg._u.b._release = CORBA_FALSE;
	      for (_ORBIT_tmpvar_84 = 0;
		   _ORBIT_tmpvar_84 < inArg._u.b._length;
		   _ORBIT_tmpvar_84++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 _ORBIT_tmpvar_86 = *((CORBA_unsigned_long *) _ORBIT_curptr);
		 _ORBIT_curptr += 4;
		 inArg._u.b._buffer[_ORBIT_tmpvar_84] =
		    (void *) _ORBIT_curptr;
		 _ORBIT_curptr +=
		    sizeof(inArg._u.b.
			   _buffer[_ORBIT_tmpvar_84][_ORBIT_tmpvar_85]) *
		    _ORBIT_tmpvar_86;
	      }

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

	      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);
	      break;
	   default:
	      inoutArg._u.w = *((CORBA_long *) _ORBIT_curptr);
	      break;
	   case 2:
	      _ORBIT_tmpvar_91 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      inoutArg._u.y = CORBA_string_alloc(_ORBIT_tmpvar_91);
	      memcpy(inoutArg._u.y, _ORBIT_curptr,
		     sizeof(inoutArg._u.y[_ORBIT_tmpvar_90]) *
		     _ORBIT_tmpvar_91);
	      _ORBIT_curptr +=
		 sizeof(inoutArg._u.y[_ORBIT_tmpvar_90]) * _ORBIT_tmpvar_91;
	      break;
	   case 3:
	   case 4:
	      inoutArg._u.z = *((CORBA_boolean *) _ORBIT_curptr);
	      break;
	   case 5:
	      _ORBIT_tmpvar_93 = *((CORBA_unsigned_long *) _ORBIT_curptr);
	      _ORBIT_curptr += 4;
	      inoutArg._u.a.a = CORBA_string_alloc(_ORBIT_tmpvar_93);
	      memcpy(inoutArg._u.a.a, _ORBIT_curptr,
		     sizeof(inoutArg._u.a.a[_ORBIT_tmpvar_92]) *
		     _ORBIT_tmpvar_93);
	      _ORBIT_curptr +=
		 sizeof(inoutArg._u.a.a[_ORBIT_tmpvar_92]) * _ORBIT_tmpvar_93;
	      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_94 = 0;
		   _ORBIT_tmpvar_94 < inoutArg._u.b._length;
		   _ORBIT_tmpvar_94++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 _ORBIT_tmpvar_96 = *((CORBA_unsigned_long *) _ORBIT_curptr);
		 _ORBIT_curptr += 4;
		 inoutArg._u.b._buffer[_ORBIT_tmpvar_94] =
		    CORBA_string_alloc(_ORBIT_tmpvar_96);
		 memcpy(inoutArg._u.b._buffer[_ORBIT_tmpvar_94],
			_ORBIT_curptr,
			sizeof(inoutArg._u.b.
			       _buffer[_ORBIT_tmpvar_94][_ORBIT_tmpvar_95]) *
			_ORBIT_tmpvar_96);
		 _ORBIT_curptr +=
		    sizeof(inoutArg._u.b.
			   _buffer[_ORBIT_tmpvar_94][_ORBIT_tmpvar_95]) *
		    _ORBIT_tmpvar_96;
	      }

	      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);
		   break;
		case 'b':
		   inoutArg._u.c._u.y = *((CORBA_char *) _ORBIT_curptr);
		   break;
		case 'c':
		case 'd':
		   inoutArg._u.c._u.z = *((CORBA_boolean *) _ORBIT_curptr);
		   break;
		case 'e':
		   _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 2);
		   memcpy(&(inoutArg._u.c._u.v), _ORBIT_curptr,
			  sizeof(inoutArg._u.c._u.v));
		   break;
		default:
		   break;
	      }
	      break;
	   case 8:
	      for (_ORBIT_tmpvar_97 = 0; _ORBIT_tmpvar_97 < 2;
		   _ORBIT_tmpvar_97++) {
		 _ORBIT_curptr = ALIGN_ADDRESS(_ORBIT_curptr, 4);
		 _ORBIT_tmpvar_99 = *((CORBA_unsigned_long *) _ORBIT_curptr);
		 _ORBIT_curptr += 4;
		 inoutArg._u.d[_ORBIT_tmpvar_97] =
		    CORBA_string_alloc(_ORBIT_tmpvar_99);
		 memcpy(inoutArg._u.d[_ORBIT_tmpvar_97], _ORBIT_curptr,
			sizeof(inoutArg._u.
			       d[_ORBIT_tmpvar_97][_ORBIT_tmpvar_98]) *
			_ORBIT_tmpvar_99);
		 _ORBIT_curptr +=
		    sizeof(inoutArg._u.
			   d[_ORBIT_tmpvar_97][_ORBIT_tmpvar_98]) *
		    _ORBIT_tmpvar_99;
	      }

	      break;
	 }
      }
   }
   _ORBIT_retval =
      _impl_opVariable(_ORBIT_servant, &(inArg), &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    register CORBA_unsigned_long _ORBIT_tmpvar_20;
	    CORBA_unsigned_long _ORBIT_tmpvar_21;
	    register CORBA_unsigned_long _ORBIT_tmpvar_22;
	    CORBA_unsigned_long _ORBIT_tmpvar_23;
	    register CORBA_unsigned_long _ORBIT_tmpvar_24;
	    register CORBA_unsigned_long _ORBIT_tmpvar_25;
	    CORBA_unsigned_long _ORBIT_tmpvar_26;
	    register CORBA_unsigned_long _ORBIT_tmpvar_27;
	    register CORBA_unsigned_long _ORBIT_tmpvar_28;
	    CORBA_unsigned_long _ORBIT_tmpvar_29;
	    register CORBA_unsigned_long _ORBIT_tmpvar_30;
	    CORBA_unsigned_long _ORBIT_tmpvar_31;
	    register CORBA_unsigned_long _ORBIT_tmpvar_32;
	    CORBA_unsigned_long _ORBIT_tmpvar_33;
	    register CORBA_unsigned_long _ORBIT_tmpvar_34;
	    register CORBA_unsigned_long _ORBIT_tmpvar_35;
	    CORBA_unsigned_long _ORBIT_tmpvar_36;
	    register CORBA_unsigned_long _ORBIT_tmpvar_37;
	    register CORBA_unsigned_long _ORBIT_tmpvar_38;
	    CORBA_unsigned_long _ORBIT_tmpvar_39;
	    register CORBA_unsigned_long _ORBIT_tmpvar_40;
	    CORBA_unsigned_long _ORBIT_tmpvar_41;
	    register CORBA_unsigned_long _ORBIT_tmpvar_42;
	    CORBA_unsigned_long _ORBIT_tmpvar_43;
	    register CORBA_unsigned_long _ORBIT_tmpvar_44;
	    register CORBA_unsigned_long _ORBIT_tmpvar_45;
	    CORBA_unsigned_long _ORBIT_tmpvar_46;
	    register CORBA_unsigned_long _ORBIT_tmpvar_47;
	    register CORBA_unsigned_long _ORBIT_tmpvar_48;
	    CORBA_unsigned_long _ORBIT_tmpvar_49;

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

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

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

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

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

		       _ORBIT_t =
			  alloca(sizeof
				 ((*_ORBIT_retval)._u.b.
				  _buffer[_ORBIT_tmpvar_24][_ORBIT_tmpvar_25])
				 * _ORBIT_tmpvar_26);
		       memcpy(_ORBIT_t,
			      ((*_ORBIT_retval)._u.b.
			       _buffer[_ORBIT_tmpvar_24]),
			      sizeof((*_ORBIT_retval)._u.b.
				     _buffer[_ORBIT_tmpvar_24]
				     [_ORBIT_tmpvar_25]) * _ORBIT_tmpvar_26);
		       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						      (_ORBIT_send_buffer),
						      (_ORBIT_t),
						      sizeof((*_ORBIT_retval).
							     _u.b.
							     _buffer
							     [_ORBIT_tmpvar_24]
							     [_ORBIT_tmpvar_25])
						      * _ORBIT_tmpvar_26);
		    }
		 }

		 break;
	      case 7:
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						&((*_ORBIT_retval)._u.c._d),
						sizeof((*_ORBIT_retval)._u.c.
						       _d));
		 switch ((*_ORBIT_retval)._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),
						     &((*_ORBIT_retval)._u.c.
						       _u.x),
						     sizeof((*_ORBIT_retval).
							    _u.c._u.x));
		      break;
		   case 'b':
		      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						     (_ORBIT_send_buffer),
						     &((*_ORBIT_retval)._u.c.
						       _u.y),
						     sizeof((*_ORBIT_retval).
							    _u.c._u.y));
		      break;
		   case 'c':
		   case 'd':
		      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						     (_ORBIT_send_buffer),
						     &((*_ORBIT_retval)._u.c.
						       _u.z),
						     sizeof((*_ORBIT_retval).
							    _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),
						     &((*_ORBIT_retval)._u.c.
						       _u.v),
						     sizeof((*_ORBIT_retval).
							    _u.c._u.v));
		      break;
		   default:
		      break;
		 }
		 break;
	      case 8:
		 for (_ORBIT_tmpvar_27 = 0; _ORBIT_tmpvar_27 < 2;
		      _ORBIT_tmpvar_27++) {
		    _ORBIT_tmpvar_29 =
		       strlen((*_ORBIT_retval)._u.d[_ORBIT_tmpvar_27]) + 1;
		    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						     (_ORBIT_send_buffer), 4);
		    {
		       guchar *_ORBIT_t;

		       _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_29));
		       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_29),
			      sizeof(_ORBIT_tmpvar_29));
		       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						      (_ORBIT_send_buffer),
						      (_ORBIT_t),
						      sizeof
						      (_ORBIT_tmpvar_29));
		    }
		    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						   (_ORBIT_send_buffer),
						   ((*_ORBIT_retval)._u.
						    d[_ORBIT_tmpvar_27]),
						   sizeof((*_ORBIT_retval)._u.
							  d[_ORBIT_tmpvar_27]
							  [_ORBIT_tmpvar_28])
						   * _ORBIT_tmpvar_29);
		 }

		 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_31 = strlen(inoutArg._u.y) + 1;
		 {
		    guchar *_ORBIT_t;

		    _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_31));
		    memcpy(_ORBIT_t, &(_ORBIT_tmpvar_31),
			   sizeof(_ORBIT_tmpvar_31));
		    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						   (_ORBIT_send_buffer),
						   (_ORBIT_t),
						   sizeof(_ORBIT_tmpvar_31));
		 }
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						(inoutArg._u.y),
						sizeof(inoutArg._u.
						       y[_ORBIT_tmpvar_30]) *
						_ORBIT_tmpvar_31);
		 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_33 = strlen(inoutArg._u.a.a) + 1;
		 {
		    guchar *_ORBIT_t;

		    _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_33));
		    memcpy(_ORBIT_t, &(_ORBIT_tmpvar_33),
			   sizeof(_ORBIT_tmpvar_33));
		    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						   (_ORBIT_send_buffer),
						   (_ORBIT_t),
						   sizeof(_ORBIT_tmpvar_33));
		 }
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						(inoutArg._u.a.a),
						sizeof(inoutArg._u.a.
						       a[_ORBIT_tmpvar_32]) *
						_ORBIT_tmpvar_33);
		 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_34 = 0;
		      _ORBIT_tmpvar_34 < inoutArg._u.b._length;
		      _ORBIT_tmpvar_34++) {
		    _ORBIT_tmpvar_36 =
		       strlen(inoutArg._u.b._buffer[_ORBIT_tmpvar_34]) + 1;
		    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						     (_ORBIT_send_buffer), 4);
		    {
		       guchar *_ORBIT_t;

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

		       _ORBIT_t =
			  alloca(sizeof
				 (inoutArg._u.b.
				  _buffer[_ORBIT_tmpvar_34][_ORBIT_tmpvar_35])
				 * _ORBIT_tmpvar_36);
		       memcpy(_ORBIT_t,
			      (inoutArg._u.b._buffer[_ORBIT_tmpvar_34]),
			      sizeof(inoutArg._u.b.
				     _buffer[_ORBIT_tmpvar_34]
				     [_ORBIT_tmpvar_35]) * _ORBIT_tmpvar_36);
		       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						      (_ORBIT_send_buffer),
						      (_ORBIT_t),
						      sizeof(inoutArg._u.b.
							     _buffer
							     [_ORBIT_tmpvar_34]
							     [_ORBIT_tmpvar_35])
						      * _ORBIT_tmpvar_36);
		    }
		 }

		 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_37 = 0; _ORBIT_tmpvar_37 < 2;
		      _ORBIT_tmpvar_37++) {
		    _ORBIT_tmpvar_39 =
		       strlen(inoutArg._u.d[_ORBIT_tmpvar_37]) + 1;
		    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						     (_ORBIT_send_buffer), 4);
		    {
		       guchar *_ORBIT_t;

		       _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_39));
		       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_39),
			      sizeof(_ORBIT_tmpvar_39));
		       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						      (_ORBIT_send_buffer),
						      (_ORBIT_t),
						      sizeof
						      (_ORBIT_tmpvar_39));
		    }
		    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						   (_ORBIT_send_buffer),
						   (inoutArg._u.
						    d[_ORBIT_tmpvar_37]),
						   sizeof(inoutArg._u.
							  d[_ORBIT_tmpvar_37]
							  [_ORBIT_tmpvar_38])
						   * _ORBIT_tmpvar_39);
		 }

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

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

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

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

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

		       _ORBIT_t =
			  alloca(sizeof
				 ((*outArg)._u.b.
				  _buffer[_ORBIT_tmpvar_44][_ORBIT_tmpvar_45])
				 * _ORBIT_tmpvar_46);
		       memcpy(_ORBIT_t,
			      ((*outArg)._u.b._buffer[_ORBIT_tmpvar_44]),
			      sizeof((*outArg)._u.b.
				     _buffer[_ORBIT_tmpvar_44]
				     [_ORBIT_tmpvar_45]) * _ORBIT_tmpvar_46);
		       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						      (_ORBIT_send_buffer),
						      (_ORBIT_t),
						      sizeof((*outArg)._u.b.
							     _buffer
							     [_ORBIT_tmpvar_44]
							     [_ORBIT_tmpvar_45])
						      * _ORBIT_tmpvar_46);
		    }
		 }

		 break;
	      case 7:
		 giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						(_ORBIT_send_buffer),
						&((*outArg)._u.c._d),
						sizeof((*outArg)._u.c._d));
		 switch ((*outArg)._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),
						     &((*outArg)._u.c._u.x),
						     sizeof((*outArg)._u.c._u.
							    x));
		      break;
		   case 'b':
		      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						     (_ORBIT_send_buffer),
						     &((*outArg)._u.c._u.y),
						     sizeof((*outArg)._u.c._u.
							    y));
		      break;
		   case 'c':
		   case 'd':
		      giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						     (_ORBIT_send_buffer),
						     &((*outArg)._u.c._u.z),
						     sizeof((*outArg)._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),
						     &((*outArg)._u.c._u.v),
						     sizeof((*outArg)._u.c._u.
							    v));
		      break;
		   default:
		      break;
		 }
		 break;
	      case 8:
		 for (_ORBIT_tmpvar_47 = 0; _ORBIT_tmpvar_47 < 2;
		      _ORBIT_tmpvar_47++) {
		    _ORBIT_tmpvar_49 =
		       strlen((*outArg)._u.d[_ORBIT_tmpvar_47]) + 1;
		    giop_message_buffer_do_alignment(GIOP_MESSAGE_BUFFER
						     (_ORBIT_send_buffer), 4);
		    {
		       guchar *_ORBIT_t;

		       _ORBIT_t = alloca(sizeof(_ORBIT_tmpvar_49));
		       memcpy(_ORBIT_t, &(_ORBIT_tmpvar_49),
			      sizeof(_ORBIT_tmpvar_49));
		       giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						      (_ORBIT_send_buffer),
						      (_ORBIT_t),
						      sizeof
						      (_ORBIT_tmpvar_49));
		    }
		    giop_message_buffer_append_mem(GIOP_MESSAGE_BUFFER
						   (_ORBIT_send_buffer),
						   ((*outArg)._u.
						    d[_ORBIT_tmpvar_47]),
						   sizeof((*outArg)._u.
							  d[_ORBIT_tmpvar_47]
							  [_ORBIT_tmpvar_48])
						   * _ORBIT_tmpvar_49);
		 }

		 break;
	    }
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      test_VariableLengthUnion__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_skel_test_AnyServer_opAnyStrSeq(POA_test_AnyServer * _ORBIT_servant,
				       GIOPRecvBuffer * _ORBIT_recv_buffer,
				       CORBA_Environment * ev,
				       CORBA_any *
				       (*_impl_opAnyStrSeq)
				       (PortableServer_Servant _servant,
					CORBA_Environment * ev))
{
   CORBA_any *_ORBIT_retval;

   _ORBIT_retval = _impl_opAnyStrSeq(_ORBIT_servant, ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_any(_ORBIT_send_buffer, &((*_ORBIT_retval)));
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
   }
}
void
_ORBIT_skel_test_AnyServer_opAnyLong(POA_test_AnyServer * _ORBIT_servant,
				     GIOPRecvBuffer * _ORBIT_recv_buffer,
				     CORBA_Environment * ev,
				     CORBA_any *
				     (*_impl_opAnyLong)
				     (PortableServer_Servant _servant,
				      const CORBA_any * inArg,
				      CORBA_any * inoutArg,
				      CORBA_any ** outArg,
				      CORBA_Environment * ev))
{
   CORBA_any *_ORBIT_retval;
   CORBA_any inArg = { NULL, NULL, CORBA_FALSE };
   CORBA_any inoutArg = { NULL, NULL, CORBA_FALSE };
   CORBA_any *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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, &(inArg), CORBA_TRUE,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _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,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _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, &(inArg), CORBA_TRUE,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _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,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
   }
   _ORBIT_retval =
      _impl_opAnyLong(_ORBIT_servant, &(inArg), &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_any(_ORBIT_send_buffer, &((*_ORBIT_retval)));
	    ORBit_marshal_any(_ORBIT_send_buffer, &(inoutArg));
	    ORBit_marshal_any(_ORBIT_send_buffer, &((*outArg)));
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      CORBA_any__free(&inArg, NULL, CORBA_FALSE);
      CORBA_any__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_skel_test_AnyServer_opAnyString(POA_test_AnyServer * _ORBIT_servant,
				       GIOPRecvBuffer * _ORBIT_recv_buffer,
				       CORBA_Environment * ev,
				       CORBA_any *
				       (*_impl_opAnyString)
				       (PortableServer_Servant _servant,
					const CORBA_any * inArg,
					CORBA_any * inoutArg,
					CORBA_any ** outArg,
					CORBA_Environment * ev))
{
   CORBA_any *_ORBIT_retval;
   CORBA_any inArg = { NULL, NULL, CORBA_FALSE };
   CORBA_any inoutArg = { NULL, NULL, CORBA_FALSE };
   CORBA_any *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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, &(inArg), CORBA_TRUE,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _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,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _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, &(inArg), CORBA_TRUE,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _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,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
   }
   _ORBIT_retval =
      _impl_opAnyString(_ORBIT_servant, &(inArg), &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_any(_ORBIT_send_buffer, &((*_ORBIT_retval)));
	    ORBit_marshal_any(_ORBIT_send_buffer, &(inoutArg));
	    ORBit_marshal_any(_ORBIT_send_buffer, &((*outArg)));
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      CORBA_any__free(&inArg, NULL, CORBA_FALSE);
      CORBA_any__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_skel_test_AnyServer_opAnyStruct(POA_test_AnyServer * _ORBIT_servant,
				       GIOPRecvBuffer * _ORBIT_recv_buffer,
				       CORBA_Environment * ev,
				       CORBA_any *
				       (*_impl_opAnyStruct)
				       (PortableServer_Servant _servant,
					const CORBA_any * inArg,
					CORBA_any * inoutArg,
					CORBA_any ** outArg,
					CORBA_Environment * ev))
{
   CORBA_any *_ORBIT_retval;
   CORBA_any inArg = { NULL, NULL, CORBA_FALSE };
   CORBA_any inoutArg = { NULL, NULL, CORBA_FALSE };
   CORBA_any *outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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, &(inArg), CORBA_TRUE,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _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,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _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, &(inArg), CORBA_TRUE,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _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,
			     (((ORBit_ObjectKey *) _ORBIT_servant->_private)->
			      object->orb));
	 _ORBIT_curptr = GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur;
      }
   }
   _ORBIT_retval =
      _impl_opAnyStruct(_ORBIT_servant, &(inArg), &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_marshal_any(_ORBIT_send_buffer, &((*_ORBIT_retval)));
	    ORBit_marshal_any(_ORBIT_send_buffer, &(inoutArg));
	    ORBit_marshal_any(_ORBIT_send_buffer, &((*outArg)));
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(_ORBIT_retval);
      CORBA_any__free(&inArg, NULL, CORBA_FALSE);
      CORBA_any__free(&inoutArg, NULL, CORBA_TRUE);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_free(outArg);
   }
}
void
_ORBIT_skel_test_AnyServer_opTypeCode(POA_test_AnyServer * _ORBIT_servant,
				      GIOPRecvBuffer * _ORBIT_recv_buffer,
				      CORBA_Environment * ev,
				      CORBA_TypeCode(*_impl_opTypeCode)
				      (PortableServer_Servant _servant,
				       const CORBA_TypeCode inArg,
				       CORBA_TypeCode * inoutArg,
				       CORBA_TypeCode * outArg,
				       CORBA_Environment * ev))
{
   CORBA_TypeCode _ORBIT_retval;
   CORBA_TypeCode inArg;
   CORBA_TypeCode inoutArg;
   CORBA_TypeCode outArg;

   {				/* demarshalling */
      guchar *_ORBIT_curptr;

      _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(&inArg, _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;
      } else {
	 GIOP_RECV_BUFFER(_ORBIT_recv_buffer)->cur = _ORBIT_curptr;
	 ORBit_decode_CORBA_TypeCode(&inArg, _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;
      }
   }
   _ORBIT_retval =
      _impl_opTypeCode(_ORBIT_servant, inArg, &(inoutArg), &(outArg), ev);
   {				/* marshalling */
      register GIOPSendBuffer *_ORBIT_send_buffer;

      _ORBIT_send_buffer =
	 giop_send_reply_buffer_use(GIOP_MESSAGE_BUFFER(_ORBIT_recv_buffer)->
				    connection, NULL,
				    _ORBIT_recv_buffer->message.u.request.
				    request_id, ev->_major);
      if (_ORBIT_send_buffer) {
	 if (ev->_major == CORBA_NO_EXCEPTION) {
	    ORBit_encode_CORBA_TypeCode(_ORBIT_retval, _ORBIT_send_buffer);
	    ORBit_encode_CORBA_TypeCode(inoutArg, _ORBIT_send_buffer);
	    ORBit_encode_CORBA_TypeCode(outArg, _ORBIT_send_buffer);
	 } else
	    ORBit_send_system_exception(_ORBIT_send_buffer, ev);
	 giop_send_buffer_write(_ORBIT_send_buffer);
	 giop_send_buffer_unuse(_ORBIT_send_buffer);
      }
      CORBA_Object_release((CORBA_Object) inArg, ev);
      CORBA_Object_release((CORBA_Object) inoutArg, ev);
      if (ev->_major == CORBA_NO_EXCEPTION)
	 CORBA_Object_release((CORBA_Object) outArg, ev);
   }
}
static ORBitSkeleton
get_skel_test_TestFactory(POA_test_TestFactory * servant,
			  GIOPRecvBuffer * _ORBIT_recv_buffer,
			  gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'c':
	if (strcmp((opname + 1), "reateTransientObj"))
	   break;
	*impl =
	   (gpointer) servant->vepv->test_TestFactory_epv->createTransientObj;
	return (ORBitSkeleton)
	   _ORBIT_skel_test_TestFactory_createTransientObj;
	break;
     case 'g':
	switch (opname[1]) {
	  case 'e':
	     switch (opname[2]) {
	       case 't':
		  switch (opname[3]) {
		    case 'A':
		       switch (opname[4]) {
			 case 'n':
			    if (strcmp((opname + 5), "yServer"))
			       break;
			    *impl =
			       (gpointer) servant->vepv->
			       test_TestFactory_epv->getAnyServer;
			    return (ORBitSkeleton)
			       _ORBIT_skel_test_TestFactory_getAnyServer;
			    break;
			 case 'r':
			    if (strcmp((opname + 5), "rayServer"))
			       break;
			    *impl =
			       (gpointer) servant->vepv->
			       test_TestFactory_epv->getArrayServer;
			    return (ORBitSkeleton)
			       _ORBIT_skel_test_TestFactory_getArrayServer;
			    break;
			 default:
			    break;
		       }
		       break;
		    case 'B':
		       switch (opname[4]) {
			 case 'a':
			    switch (opname[5]) {
			      case 's':
				 switch (opname[6]) {
				   case 'e':
				      if (strcmp((opname + 7), "Server"))
					 break;
				      *impl =
					 (gpointer) servant->vepv->
					 test_TestFactory_epv->getBaseServer;
				      return (ORBitSkeleton)
					 _ORBIT_skel_test_TestFactory_getBaseServer;
				      break;
				   case 'i':
				      if (strcmp((opname + 7), "cServer"))
					 break;
				      *impl =
					 (gpointer) servant->vepv->
					 test_TestFactory_epv->getBasicServer;
				      return (ORBitSkeleton)
					 _ORBIT_skel_test_TestFactory_getBasicServer;
				      break;
				   default:
				      break;
				 }
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    case 'D':
		       switch (opname[4]) {
			 case 'e':
			    switch (opname[5]) {
			      case 'r':
				 switch (opname[6]) {
				   case 'i':
				      switch (opname[7]) {
					case 'v':
					   switch (opname[8]) {
					     case 'e':
						switch (opname[9]) {
						  case 'd':
						     switch (opname[10]) {
						       case 'S':
							  switch (opname[11]) {
							    case 'e':
							       switch (opname
								       [12]) {
								 case 'r':
								    switch
								       (opname
									[13])
								      {
								      case 'v':
									 switch
									    (opname
									     [14])
									   {
									   case 'e':
									      switch
										 (opname
										  [15])
										{
										case 'r':
										   switch
										      (opname
										       [16])
										     {
										     case '\0':
											*impl
											   =
											   (gpointer)
											   servant->
											   vepv->
											   test_TestFactory_epv->
											   getDerivedServer;
											return
											   (ORBitSkeleton)
											   _ORBIT_skel_test_TestFactory_getDerivedServer;
											break;
										     case 'A':
											switch
											   (opname
											    [17])
											  {
											  case 's':
											     switch
												(opname
												 [18])
											       {
											       case 'B':
												  switch
												     (opname
												      [19])
												    {
												    case '2':
												       if (strcmp((opname + 20), ""))
													  break;
												       *impl
													  =
													  (gpointer)
													  servant->
													  vepv->
													  test_TestFactory_epv->
													  getDerivedServerAsB2;
												       return
													  (ORBitSkeleton)
													  _ORBIT_skel_test_TestFactory_getDerivedServerAsB2;
												       break;
												    case 'a':
												       if (strcmp((opname + 20), "seServer"))
													  break;
												       *impl
													  =
													  (gpointer)
													  servant->
													  vepv->
													  test_TestFactory_epv->
													  getDerivedServerAsBaseServer;
												       return
													  (ORBitSkeleton)
													  _ORBIT_skel_test_TestFactory_getDerivedServerAsBaseServer;
												       break;
												    default:
												       break;
												  }
												  break;
											       default:
												  break;
											     }
											     break;
											  default:
											     break;
											}
											break;
										     default:
											break;
										   }
										   break;
										default:
										   break;
									      }
									      break;
									   default:
									      break;
									 }
									 break;
								      default:
									 break;
								    }
								    break;
								 default:
								    break;
							       }
							       break;
							    default:
							       break;
							  }
							  break;
						       default:
							  break;
						     }
						     break;
						  default:
						     break;
						}
						break;
					     default:
						break;
					   }
					   break;
					default:
					   break;
				      }
				      break;
				   default:
				      break;
				 }
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    case 'S':
		       switch (opname[4]) {
			 case 'e':
			    if (strcmp((opname + 5), "quenceServer"))
			       break;
			    *impl =
			       (gpointer) servant->vepv->
			       test_TestFactory_epv->getSequenceServer;
			    return (ORBitSkeleton)
			       _ORBIT_skel_test_TestFactory_getSequenceServer;
			    break;
			 case 't':
			    if (strcmp((opname + 5), "ructServer"))
			       break;
			    *impl =
			       (gpointer) servant->vepv->
			       test_TestFactory_epv->getStructServer;
			    return (ORBitSkeleton)
			       _ORBIT_skel_test_TestFactory_getStructServer;
			    break;
			 default:
			    break;
		       }
		       break;
		    case 'U':
		       if (strcmp((opname + 4), "nionServer"))
			  break;
		       *impl =
			  (gpointer) servant->vepv->test_TestFactory_epv->
			  getUnionServer;
		       return (ORBitSkeleton)
			  _ORBIT_skel_test_TestFactory_getUnionServer;
		       break;
		    default:
		       break;
		  }
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_TestFactory(CORBA_Object obj,
				   POA_test_TestFactory * servant)
{
   obj->vepv[test_TestFactory__classid] = servant->vepv->test_TestFactory_epv;
}

void
POA_test_TestFactory__init(PortableServer_Servant servant,
			   CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_TestFactory,
"IDL:orbit/test/TestFactory:1.0", (ORBit_local_objref_init) & init_local_objref_test_TestFactory };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_TestFactory__classid)
      test_TestFactory__classid = ORBit_register_class(&class_info);
}

void
POA_test_TestFactory__fini(PortableServer_Servant servant,
			   CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_TransientObj(POA_test_TransientObj * servant,
			   GIOPRecvBuffer * _ORBIT_recv_buffer,
			   gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'r':
	if (strcmp((opname + 1), "emove"))
	   break;
	*impl = (gpointer) servant->vepv->test_TransientObj_epv->remove;
	return (ORBitSkeleton) _ORBIT_skel_test_TransientObj_remove;
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_TransientObj(CORBA_Object obj,
				    POA_test_TransientObj * servant)
{
   obj->vepv[test_TransientObj__classid] =
      servant->vepv->test_TransientObj_epv;
}

void
POA_test_TransientObj__init(PortableServer_Servant servant,
			    CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_TransientObj,
"IDL:orbit/test/TransientObj:1.0", (ORBit_local_objref_init) & init_local_objref_test_TransientObj };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_TransientObj__classid)
      test_TransientObj__classid = ORBit_register_class(&class_info);
}

void
POA_test_TransientObj__fini(PortableServer_Servant servant,
			    CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_StructServer(POA_test_StructServer * servant,
			   GIOPRecvBuffer * _ORBIT_recv_buffer,
			   gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'o':
	switch (opname[1]) {
	  case 'p':
	     switch (opname[2]) {
	       case 'C':
		  if (strcmp((opname + 3), "ompound"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_StructServer_epv->
		     opCompound;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_StructServer_opCompound;
		  break;
	       case 'F':
		  if (strcmp((opname + 3), "ixed"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_StructServer_epv->opFixed;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_StructServer_opFixed;
		  break;
	       case 'V':
		  if (strcmp((opname + 3), "ariable"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_StructServer_epv->
		     opVariable;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_StructServer_opVariable;
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_StructServer(CORBA_Object obj,
				    POA_test_StructServer * servant)
{
   obj->vepv[test_StructServer__classid] =
      servant->vepv->test_StructServer_epv;
}

void
POA_test_StructServer__init(PortableServer_Servant servant,
			    CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_StructServer,
"IDL:orbit/test/StructServer:1.0", (ORBit_local_objref_init) & init_local_objref_test_StructServer };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_StructServer__classid)
      test_StructServer__classid = ORBit_register_class(&class_info);
}

void
POA_test_StructServer__fini(PortableServer_Servant servant,
			    CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_SequenceServer(POA_test_SequenceServer * servant,
			     GIOPRecvBuffer * _ORBIT_recv_buffer,
			     gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'o':
	switch (opname[1]) {
	  case 'p':
	     switch (opname[2]) {
	       case 'B':
		  if (strcmp((opname + 3), "oundedStructSeq"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_SequenceServer_epv->
		     opBoundedStructSeq;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_SequenceServer_opBoundedStructSeq;
		  break;
	       case 'S':
		  if (strcmp((opname + 3), "trSeq"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_SequenceServer_epv->
		     opStrSeq;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_SequenceServer_opStrSeq;
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_SequenceServer(CORBA_Object obj,
				      POA_test_SequenceServer * servant)
{
   obj->vepv[test_SequenceServer__classid] =
      servant->vepv->test_SequenceServer_epv;
}

void
POA_test_SequenceServer__init(PortableServer_Servant servant,
			      CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_SequenceServer,
"IDL:orbit/test/SequenceServer:1.0", (ORBit_local_objref_init) & init_local_objref_test_SequenceServer };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_SequenceServer__classid)
      test_SequenceServer__classid = ORBit_register_class(&class_info);
}

void
POA_test_SequenceServer__fini(PortableServer_Servant servant,
			      CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_ArrayServer(POA_test_ArrayServer * servant,
			  GIOPRecvBuffer * _ORBIT_recv_buffer,
			  gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'o':
	switch (opname[1]) {
	  case 'p':
	     switch (opname[2]) {
	       case 'L':
		  if (strcmp((opname + 3), "ongArray"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_ArrayServer_epv->
		     opLongArray;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_ArrayServer_opLongArray;
		  break;
	       case 'S':
		  if (strcmp((opname + 3), "trArray"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_ArrayServer_epv->
		     opStrArray;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_ArrayServer_opStrArray;
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_ArrayServer(CORBA_Object obj,
				   POA_test_ArrayServer * servant)
{
   obj->vepv[test_ArrayServer__classid] = servant->vepv->test_ArrayServer_epv;
}

void
POA_test_ArrayServer__init(PortableServer_Servant servant,
			   CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_ArrayServer,
"IDL:orbit/test/ArrayServer:1.0", (ORBit_local_objref_init) & init_local_objref_test_ArrayServer };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_ArrayServer__classid)
      test_ArrayServer__classid = ORBit_register_class(&class_info);
}

void
POA_test_ArrayServer__fini(PortableServer_Servant servant,
			   CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_BasicServer(POA_test_BasicServer * servant,
			  GIOPRecvBuffer * _ORBIT_recv_buffer,
			  gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case '_':
	switch (opname[1]) {
	  case 'g':
	     switch (opname[2]) {
	       case 'e':
		  switch (opname[3]) {
		    case 't':
		       switch (opname[4]) {
			 case '_':
			    switch (opname[5]) {
			      case 'b':
				 if (strcmp((opname + 6), "ah"))
				    break;
				 *impl =
				    (gpointer) servant->vepv->
				    test_BasicServer_epv->_get_bah;
				 return (ORBitSkeleton)
				    _ORBIT_skel_test_BasicServer__get_bah;
				 break;
			      case 'f':
				 if (strcmp((opname + 6), "oo"))
				    break;
				 *impl =
				    (gpointer) servant->vepv->
				    test_BasicServer_epv->_get_foo;
				 return (ORBitSkeleton)
				    _ORBIT_skel_test_BasicServer__get_foo;
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    default:
		       break;
		  }
		  break;
	       default:
		  break;
	     }
	     break;
	  case 's':
	     if (strcmp((opname + 2), "et_foo"))
		break;
	     *impl = (gpointer) servant->vepv->test_BasicServer_epv->_set_foo;
	     return (ORBitSkeleton) _ORBIT_skel_test_BasicServer__set_foo;
	     break;
	  default:
	     break;
	}
	break;
     case 'o':
	switch (opname[1]) {
	  case 'p':
	     switch (opname[2]) {
	       case 'E':
		  switch (opname[3]) {
		    case 'n':
		       if (strcmp((opname + 4), "um"))
			  break;
		       *impl =
			  (gpointer) servant->vepv->test_BasicServer_epv->
			  opEnum;
		       return (ORBitSkeleton)
			  _ORBIT_skel_test_BasicServer_opEnum;
		       break;
		    case 'x':
		       if (strcmp((opname + 4), "ception"))
			  break;
		       *impl =
			  (gpointer) servant->vepv->test_BasicServer_epv->
			  opException;
		       return (ORBitSkeleton)
			  _ORBIT_skel_test_BasicServer_opException;
		       break;
		    default:
		       break;
		  }
		  break;
	       case 'L':
		  if (strcmp((opname + 3), "ong"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_BasicServer_epv->opLong;
		  return (ORBitSkeleton) _ORBIT_skel_test_BasicServer_opLong;
		  break;
	       case 'S':
		  if (strcmp((opname + 3), "tring"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_BasicServer_epv->opString;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_BasicServer_opString;
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_BasicServer(CORBA_Object obj,
				   POA_test_BasicServer * servant)
{
   obj->vepv[test_BasicServer__classid] = servant->vepv->test_BasicServer_epv;
}

void
POA_test_BasicServer__init(PortableServer_Servant servant,
			   CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_BasicServer,
"IDL:orbit/test/BasicServer:1.0", (ORBit_local_objref_init) & init_local_objref_test_BasicServer };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_BasicServer__classid)
      test_BasicServer__classid = ORBit_register_class(&class_info);
}

void
POA_test_BasicServer__fini(PortableServer_Servant servant,
			   CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_BaseServer(POA_test_BaseServer * servant,
			 GIOPRecvBuffer * _ORBIT_recv_buffer, gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case '_':
	switch (opname[1]) {
	  case 'g':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_get_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__get_attribPolymorphic;
	     break;
	  case 's':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_set_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__set_attribPolymorphic;
	     break;
	  default:
	     break;
	}
	break;
     case 'o':
	if (strcmp((opname + 1), "pPolymorphic"))
	   break;
	*impl = (gpointer) servant->vepv->test_BaseServer_epv->opPolymorphic;
	return (ORBitSkeleton) _ORBIT_skel_test_BaseServer_opPolymorphic;
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_BaseServer(CORBA_Object obj,
				  POA_test_BaseServer * servant)
{
   obj->vepv[test_BaseServer__classid] = servant->vepv->test_BaseServer_epv;
}

void
POA_test_BaseServer__init(PortableServer_Servant servant,
			  CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_BaseServer,
"IDL:orbit/test/BaseServer:1.0", (ORBit_local_objref_init) & init_local_objref_test_BaseServer };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_BaseServer__classid)
      test_BaseServer__classid = ORBit_register_class(&class_info);
}

void
POA_test_BaseServer__fini(PortableServer_Servant servant,
			  CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_B1(POA_test_B1 * servant,
		 GIOPRecvBuffer * _ORBIT_recv_buffer, gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case '_':
	switch (opname[1]) {
	  case 'g':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_get_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__get_attribPolymorphic;
	     break;
	  case 's':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_set_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__set_attribPolymorphic;
	     break;
	  default:
	     break;
	}
	break;
     case 'o':
	if (strcmp((opname + 1), "pPolymorphic"))
	   break;
	*impl = (gpointer) servant->vepv->test_BaseServer_epv->opPolymorphic;
	return (ORBitSkeleton) _ORBIT_skel_test_BaseServer_opPolymorphic;
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_B1(CORBA_Object obj, POA_test_B1 * servant)
{
   obj->vepv[test_BaseServer__classid] = servant->vepv->test_BaseServer_epv;
   obj->vepv[test_B1__classid] = servant->vepv->test_B1_epv;
}

void
POA_test_B1__init(PortableServer_Servant servant, CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_B1, "IDL:orbit/test/B1:1.0",
(ORBit_local_objref_init) & init_local_objref_test_B1 };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   POA_test_BaseServer__init(servant, env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_B1__classid)
      test_B1__classid = ORBit_register_class(&class_info);
}

void
POA_test_B1__fini(PortableServer_Servant servant, CORBA_Environment * env)
{
   POA_test_BaseServer__fini(servant, env);
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_B2(POA_test_B2 * servant,
		 GIOPRecvBuffer * _ORBIT_recv_buffer, gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case '_':
	switch (opname[1]) {
	  case 'g':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_get_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__get_attribPolymorphic;
	     break;
	  case 's':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_set_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__set_attribPolymorphic;
	     break;
	  default:
	     break;
	}
	break;
     case 'o':
	if (strcmp((opname + 1), "pPolymorphic"))
	   break;
	*impl = (gpointer) servant->vepv->test_BaseServer_epv->opPolymorphic;
	return (ORBitSkeleton) _ORBIT_skel_test_BaseServer_opPolymorphic;
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_B2(CORBA_Object obj, POA_test_B2 * servant)
{
   obj->vepv[test_BaseServer__classid] = servant->vepv->test_BaseServer_epv;
   obj->vepv[test_B2__classid] = servant->vepv->test_B2_epv;
}

void
POA_test_B2__init(PortableServer_Servant servant, CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_B2, "IDL:orbit/test/B2:1.0",
(ORBit_local_objref_init) & init_local_objref_test_B2 };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   POA_test_BaseServer__init(servant, env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_B2__classid)
      test_B2__classid = ORBit_register_class(&class_info);
}

void
POA_test_B2__fini(PortableServer_Servant servant, CORBA_Environment * env)
{
   POA_test_BaseServer__fini(servant, env);
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_C1(POA_test_C1 * servant,
		 GIOPRecvBuffer * _ORBIT_recv_buffer, gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case '_':
	switch (opname[1]) {
	  case 'g':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_get_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__get_attribPolymorphic;
	     break;
	  case 's':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_set_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__set_attribPolymorphic;
	     break;
	  default:
	     break;
	}
	break;
     case 'o':
	if (strcmp((opname + 1), "pPolymorphic"))
	   break;
	*impl = (gpointer) servant->vepv->test_BaseServer_epv->opPolymorphic;
	return (ORBitSkeleton) _ORBIT_skel_test_BaseServer_opPolymorphic;
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_C1(CORBA_Object obj, POA_test_C1 * servant)
{
   obj->vepv[test_BaseServer__classid] = servant->vepv->test_BaseServer_epv;
   obj->vepv[test_B1__classid] = servant->vepv->test_B1_epv;
   obj->vepv[test_B2__classid] = servant->vepv->test_B2_epv;
   obj->vepv[test_C1__classid] = servant->vepv->test_C1_epv;
}

void
POA_test_C1__init(PortableServer_Servant servant, CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_C1, "IDL:orbit/test/C1:1.0",
(ORBit_local_objref_init) & init_local_objref_test_C1 };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   POA_test_B1__init(servant, env);
   POA_test_B2__init(servant, env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_C1__classid)
      test_C1__classid = ORBit_register_class(&class_info);
}

void
POA_test_C1__fini(PortableServer_Servant servant, CORBA_Environment * env)
{
   POA_test_B2__fini(servant, env);
   POA_test_B1__fini(servant, env);
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_DerivedServer(POA_test_DerivedServer * servant,
			    GIOPRecvBuffer * _ORBIT_recv_buffer,
			    gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case '_':
	switch (opname[1]) {
	  case 'g':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_get_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__get_attribPolymorphic;
	     break;
	  case 's':
	     if (strcmp((opname + 2), "et_attribPolymorphic"))
		break;
	     *impl =
		(gpointer) servant->vepv->test_BaseServer_epv->
		_set_attribPolymorphic;
	     return (ORBitSkeleton)
		_ORBIT_skel_test_BaseServer__set_attribPolymorphic;
	     break;
	  default:
	     break;
	}
	break;
     case 'o':
	if (strcmp((opname + 1), "pPolymorphic"))
	   break;
	*impl = (gpointer) servant->vepv->test_BaseServer_epv->opPolymorphic;
	return (ORBitSkeleton) _ORBIT_skel_test_BaseServer_opPolymorphic;
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_DerivedServer(CORBA_Object obj,
				     POA_test_DerivedServer * servant)
{
   obj->vepv[test_BaseServer__classid] = servant->vepv->test_BaseServer_epv;
   obj->vepv[test_B1__classid] = servant->vepv->test_B1_epv;
   obj->vepv[test_B2__classid] = servant->vepv->test_B2_epv;
   obj->vepv[test_C1__classid] = servant->vepv->test_C1_epv;
   obj->vepv[test_DerivedServer__classid] =
      servant->vepv->test_DerivedServer_epv;
}

void
POA_test_DerivedServer__init(PortableServer_Servant servant,
			     CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_DerivedServer,
"IDL:orbit/test/DerivedServer:1.0", (ORBit_local_objref_init) & init_local_objref_test_DerivedServer };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   POA_test_C1__init(servant, env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_DerivedServer__classid)
      test_DerivedServer__classid = ORBit_register_class(&class_info);
}

void
POA_test_DerivedServer__fini(PortableServer_Servant servant,
			     CORBA_Environment * env)
{
   POA_test_C1__fini(servant, env);
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_UnionServer(POA_test_UnionServer * servant,
			  GIOPRecvBuffer * _ORBIT_recv_buffer,
			  gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'o':
	switch (opname[1]) {
	  case 'p':
	     switch (opname[2]) {
	       case 'F':
		  if (strcmp((opname + 3), "ixed"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_UnionServer_epv->opFixed;
		  return (ORBitSkeleton) _ORBIT_skel_test_UnionServer_opFixed;
		  break;
	       case 'V':
		  if (strcmp((opname + 3), "ariable"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_UnionServer_epv->
		     opVariable;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_UnionServer_opVariable;
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_UnionServer(CORBA_Object obj,
				   POA_test_UnionServer * servant)
{
   obj->vepv[test_UnionServer__classid] = servant->vepv->test_UnionServer_epv;
}

void
POA_test_UnionServer__init(PortableServer_Servant servant,
			   CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_UnionServer,
"IDL:orbit/test/UnionServer:1.0", (ORBit_local_objref_init) & init_local_objref_test_UnionServer };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_UnionServer__classid)
      test_UnionServer__classid = ORBit_register_class(&class_info);
}

void
POA_test_UnionServer__fini(PortableServer_Servant servant,
			   CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}

static ORBitSkeleton
get_skel_test_AnyServer(POA_test_AnyServer * servant,
			GIOPRecvBuffer * _ORBIT_recv_buffer, gpointer * impl)
{
   gchar *opname = _ORBIT_recv_buffer->message.u.request.operation;

   switch (opname[0]) {
     case 'o':
	switch (opname[1]) {
	  case 'p':
	     switch (opname[2]) {
	       case 'A':
		  switch (opname[3]) {
		    case 'n':
		       switch (opname[4]) {
			 case 'y':
			    switch (opname[5]) {
			      case 'L':
				 if (strcmp((opname + 6), "ong"))
				    break;
				 *impl =
				    (gpointer) servant->vepv->
				    test_AnyServer_epv->opAnyLong;
				 return (ORBitSkeleton)
				    _ORBIT_skel_test_AnyServer_opAnyLong;
				 break;
			      case 'S':
				 switch (opname[6]) {
				   case 't':
				      switch (opname[7]) {
					case 'r':
					   switch (opname[8]) {
					     case 'S':
						if (strcmp
						    ((opname + 9), "eq"))
						   break;
						*impl =
						   (gpointer) servant->vepv->
						   test_AnyServer_epv->
						   opAnyStrSeq;
						return (ORBitSkeleton)
						   _ORBIT_skel_test_AnyServer_opAnyStrSeq;
						break;
					     case 'i':
						if (strcmp
						    ((opname + 9), "ng"))
						   break;
						*impl =
						   (gpointer) servant->vepv->
						   test_AnyServer_epv->
						   opAnyString;
						return (ORBitSkeleton)
						   _ORBIT_skel_test_AnyServer_opAnyString;
						break;
					     case 'u':
						if (strcmp
						    ((opname + 9), "ct"))
						   break;
						*impl =
						   (gpointer) servant->vepv->
						   test_AnyServer_epv->
						   opAnyStruct;
						return (ORBitSkeleton)
						   _ORBIT_skel_test_AnyServer_opAnyStruct;
						break;
					     default:
						break;
					   }
					   break;
					default:
					   break;
				      }
				      break;
				   default:
				      break;
				 }
				 break;
			      default:
				 break;
			    }
			    break;
			 default:
			    break;
		       }
		       break;
		    default:
		       break;
		  }
		  break;
	       case 'T':
		  if (strcmp((opname + 3), "ypeCode"))
		     break;
		  *impl =
		     (gpointer) servant->vepv->test_AnyServer_epv->opTypeCode;
		  return (ORBitSkeleton)
		     _ORBIT_skel_test_AnyServer_opTypeCode;
		  break;
	       default:
		  break;
	     }
	     break;
	  default:
	     break;
	}
	break;
     default:
	break;
   }
   return NULL;
}

static void
init_local_objref_test_AnyServer(CORBA_Object obj,
				 POA_test_AnyServer * servant)
{
   obj->vepv[test_AnyServer__classid] = servant->vepv->test_AnyServer_epv;
}

void
POA_test_AnyServer__init(PortableServer_Servant servant,
			 CORBA_Environment * env)
{
   static const PortableServer_ClassInfo class_info =
      { (ORBit_impl_finder) & get_skel_test_AnyServer,
"IDL:orbit/test/AnyServer:1.0", (ORBit_local_objref_init) & init_local_objref_test_AnyServer };
   PortableServer_ServantBase__init(((PortableServer_ServantBase *) servant),
				    env);
   ORBIT_OBJECT_KEY(((PortableServer_ServantBase *) servant)->_private)->
      class_info = (PortableServer_ClassInfo *) & class_info;
   if (!test_AnyServer__classid)
      test_AnyServer__classid = ORBit_register_class(&class_info);
}

void
POA_test_AnyServer__fini(PortableServer_Servant servant,
			 CORBA_Environment * env)
{
   PortableServer_ServantBase__fini(servant, env);
}
