#ifndef INTEROPERABILITY_IDL
#define INTEROPERABILITY_IDL

#include <orb.idl>

// JacORB has problems with forward declarations of structs.

#define FORWARD_DECLS_PROBLEM

// Long doubles are not supported in the idl compiler.

#define LONG_DOUBLE_PROBLEM

module Interoperability
{

   /*------------------*/
   /* data definitions */
   /*------------------*/

   // B

   enum B { b1, b2, b3 };


   // C

   struct C_struct 
   {
      short             e_short;
      unsigned short    e_ushort;
      long              e_long;
      unsigned long     e_ulong;
      float             e_float;
      double            e_double;
      char              e_char;
      boolean           e_boolean;
      octet             e_octet;
      any               e_any;
      string            e_string;
      Object            e_Object;
      CORBA::TypeCode   e_TypeCode;
   };
   
   struct Ext_C_struct 
   {
      long long            e_longLong;
      unsigned long long   e_ulongLong;
      #ifndef LONG_DOUBLE_PROBLEM
      long double          e_longDouble;
      #endif
      wchar                e_wchar;
      wstring              e_wstring;
   };

   union C_union switch(long) 
   {
      case 1:   short           e_short;
      case 2:   unsigned short  e_ushort;
      case 3:   long            e_long;
      case 4:   unsigned long   e_ulong;
      case 5:   float           e_float;
      case 6:   double          e_double;
      case 7:   char            e_char;
      case 8:   boolean         e_boolean;
      case 9:   octet           e_octet;
      case 10:  any             e_any;
      case 11:  string          e_string;
      case 12:  Object          e_Object;
      case 14:  CORBA::TypeCode        e_TypeCode;
   };    

   union Ext_C_union switch( long ) 
   {
      case 1:   long long             e_longLong;
      case 2:   unsigned long long    e_ulongLong;
      case 3:   wchar                 e_wchar;
      case 4:   wstring               e_wstring;
      #ifndef LONG_DOUBLE_PROBLEM
      case 5:   long double           e_longDouble;   
      #endif  
   };
   
   typedef sequence<short>                  C_sequence_e_short;
   typedef sequence<short, 10>              C_sequence_e_short_10;
   typedef sequence<unsigned short>         C_sequence_e_ushort;
   typedef sequence<unsigned short, 10>     C_sequence_e_ushort_10;
   typedef sequence<long>                   C_sequence_e_long;
   typedef sequence<long, 10>               C_sequence_e_long_10;
   typedef sequence<unsigned long>          C_sequence_e_ulong;
   typedef sequence<unsigned long, 10>      C_sequence_e_ulong_10;
   typedef sequence<float>                  C_sequence_e_float;
   typedef sequence<float, 10>              C_sequence_e_float_10;
   typedef sequence<double>                 C_sequence_e_double;
   typedef sequence<double, 10>             C_sequence_e_double_10;
   typedef sequence<char>                   C_sequence_e_char;
   typedef sequence<char, 10>               C_sequence_e_char_10;
   typedef sequence<boolean>                C_sequence_e_boolean;
   typedef sequence<boolean, 10>            C_sequence_e_boolean_10;
   typedef sequence<octet>                  C_sequence_e_octet;
   typedef sequence<octet, 10>              C_sequence_e_octet_10;
   typedef sequence<any>                    C_sequence_e_any;
   typedef sequence<any, 10>                C_sequence_e_any_10;
   typedef sequence<string>                 C_sequence_e_string;
   typedef sequence<string, 10>             C_sequence_e_string_10;
   typedef sequence<Object>                 C_sequence_e_Object;
   typedef sequence<Object, 10>             C_sequence_e_Object_10;
   typedef sequence<CORBA::TypeCode>               C_sequence_e_TypeCode;
   typedef sequence<CORBA::TypeCode, 10>           C_sequence_e_TypeCode_10;
   typedef sequence<long long>              C_sequence_e_longLong;
   typedef sequence<long long, 10>          C_sequence_e_longLong_10;
   typedef sequence<unsigned long long>     C_sequence_e_ulongLong;
   typedef sequence<unsigned long long, 10> C_sequence_e_ulongLong_10;
   #ifndef LONG_DOUBLE_PROBLEM
   typedef sequence<long double>            C_sequence_e_longDouble;
   #endif
   typedef sequence<wchar>                  C_sequence_e_wchar;
   typedef sequence<wstring>                C_sequence_e_wstring;

   typedef short		C_array_e_short[2];
   typedef short                C_array_e_short2[2][2];
   typedef unsigned short	C_array_e_ushort[2];
   typedef unsigned short	C_array_e_ushort2[2][2];
   typedef long		        C_array_e_long[2];
   typedef long		        C_array_e_long2[2][2];
   typedef unsigned long	C_array_e_ulong[2];
   typedef unsigned long	C_array_e_ulong2[2][2];
   typedef float		C_array_e_float[2];
   typedef float		C_array_e_float2[2][2];
   typedef double		C_array_e_double[2];
   typedef double		C_array_e_double2[2][2];
   typedef char		        C_array_e_char[2];
   typedef char		        C_array_e_char2[2][2];
   typedef boolean		C_array_e_boolean[2];
   typedef boolean		C_array_e_boolean2[2][2];
   typedef octet		C_array_e_octet[2];
   typedef octet		C_array_e_octet2[2][2];
   typedef any		        C_array_e_any[2];
   typedef any		        C_array_e_any2[2][2];
   typedef string		C_array_e_string[2];
   typedef string		C_array_e_string2[2][2];
   typedef Object		C_array_e_Object[2];
   typedef Object		C_array_e_Object2[2][2];
   typedef CORBA::TypeCode	        C_array_e_TypeCode[2];
   typedef CORBA::TypeCode	        C_array_e_TypeCode2[2][2];
   typedef long long            C_array_e_longLong[2];
   typedef long long            C_array_e_longLong2[2][2];
   typedef unsigned long long   C_array_e_ulongLong[2];
   typedef unsigned long long   C_array_e_ulongLong2[2][2];
   #ifndef LONG_DOUBLE_PROBLEM
   typedef long double          C_array_e_longDouble[2];
   #endif
   typedef wchar                C_array_e_wchar[2];
   typedef wstring              C_array_e_wstring[2];

   // D

   union D_d_short switch (short) 
   {
      case 1: long l1;
      case 2: long l2;
   };

   union D_d_ushort switch (unsigned short) 
   {
      case 1: long l1;
      case 2: long l2;
   };

   union D_d_long switch (long) 
   {
      case 1: long l1;
      case 2: long l2;
   };

   union D_d_ulong switch (unsigned long) 
   {
      case 1: long l1;
      case 2: long l2;
   };

   union D_d_char switch (char) 
   {
      case 'a': long l1;
      case 'b': long l2;
   };

   union D_d_boolean switch (boolean) 
   {
      case TRUE: long l1;
      case FALSE: long l2;
   };

   union D_d_B switch (B) 
   {
      case b1: long l1;
      case b2: long l2;
      case b3: long l3;
   };

   union D_d_longLong switch( long long )
   {
      case 1: long l1;
      case 2: long l2;
   };
   
   union D_d_ulongLong switch( unsigned long long )
   {
      case 1: long l1;
      case 2: long l2;
   };
   
   // E

   struct E_struct 
   {
      B	   e_b1;
      B	   e_b2;
   };

   union E_union switch (long) 
   {
      case 1:	B	e_b1;
      case 2:	B	e_b2;
   };

   typedef sequence<B> E_sequence;
   
   typedef B E_array[2];


   // F

   struct F_struct 
   {
      C_struct			        e_c_struct;
      C_union			        e_c_union;
      C_sequence_e_short		e_c_sequence_e_short;
      C_sequence_e_ushort		e_c_sequence_e_ushort;
      C_sequence_e_long		        e_c_sequence_e_long;
      C_sequence_e_ulong		e_c_sequence_e_ulong;
      C_sequence_e_float		e_c_sequence_e_float;
      C_sequence_e_double		e_c_sequence_e_double;
      C_sequence_e_char		        e_c_sequence_e_char;
      C_sequence_e_boolean	        e_c_sequence_e_boolean;
      C_sequence_e_octet		e_c_sequence_e_octet;
      C_sequence_e_any		        e_c_sequence_e_any;
      C_sequence_e_string		e_c_sequence_e_string;
      C_sequence_e_Object		e_c_sequence_e_Object;
      C_sequence_e_TypeCode	        e_c_sequence_e_TypeCode;
      C_array_e_short		        e_c_array_e_short;
      C_array_e_ushort		        e_c_array_e_ushort;
      C_array_e_long		        e_c_array_e_long;
      C_array_e_ulong		        e_c_array_e_ulong;
      C_array_e_float		        e_c_array_e_float;
      C_array_e_double		        e_c_array_e_double;
      C_array_e_char		        e_c_array_e_char;
      C_array_e_boolean	                e_c_array_e_boolean;
      C_array_e_octet	 	        e_c_array_e_octet;
      C_array_e_any		        e_c_array_e_any;
      C_array_e_string		        e_c_array_e_string;
      C_array_e_Object		        e_c_array_e_Object;
      C_array_e_TypeCode		e_c_array_e_TypeCode;
   };
   
   struct Ext_F_struct
   {
      Ext_C_struct              ext_e_c_struct;
      Ext_C_union               ext_e_c_union;
      C_sequence_e_longLong     e_c_sequence_e_longLong;
      C_sequence_e_ulongLong    e_c_sequence_e_ulongLong;
      #ifndef LONG_DOUBLE_PROBLEM
      C_sequence_e_longDouble   e_c_sequence_e_longDouble;
      C_array_e_longDouble      e_c_array_e_long_double;
      #endif
      C_sequence_e_wchar        e_c_sequence_e_wchar;
      C_sequence_e_wstring      e_c_sequence_e_wstring;
      C_array_e_longLong        e_c_array_e_longLong;
      C_array_e_ulongLong       e_c_array_e_ulongLong;
      C_array_e_wchar           e_c_array_e_wchar;
      C_array_e_wstring         e_c_array_e_wstring;
   };
   
   union F_union switch (long) 
   {
      case 1:     C_struct                    e_c_struct;
      case 2:     C_union                     e_c_union;
      case 3:     C_sequence_e_short          e_c_sequence_e_short;
      case 4:     C_sequence_e_ushort         e_c_sequence_e_ushort;
      case 5:     C_sequence_e_long           e_c_sequence_e_long;
      case 6:     C_sequence_e_ulong          e_c_sequence_e_ulong;
      case 7:     C_sequence_e_float          e_c_sequence_e_float;
      case 8:     C_sequence_e_double         e_c_sequence_e_double;
      case 9:     C_sequence_e_char           e_c_sequence_e_char;
      case 10:    C_sequence_e_boolean        e_c_sequence_e_boolean;
      case 11:    C_sequence_e_octet          e_c_sequence_e_octet;
      case 12:    C_sequence_e_any            e_c_sequence_e_any;
      case 13:    C_sequence_e_string         e_c_sequence_e_string;
      case 14:    C_sequence_e_Object         e_c_sequence_e_Object;
      case 16:    C_sequence_e_TypeCode       e_c_sequence_e_TypeCode;
      case 17:    C_array_e_short             e_c_array_e_short;
      case 18:    C_array_e_ushort            e_c_array_e_ushort;
      case 19:    C_array_e_long              e_c_array_e_long;
      case 20:    C_array_e_ulong             e_c_array_e_ulong;
      case 21:    C_array_e_float             e_c_array_e_float;
      case 22:    C_array_e_double            e_c_array_e_double;
      case 23:    C_array_e_char              e_c_array_e_char;
      case 24:    C_array_e_boolean           e_c_array_e_boolean;
      case 25:    C_array_e_octet             e_c_array_e_octet;
      case 26:    C_array_e_any               e_c_array_e_any;
      case 27:    C_array_e_string            e_c_array_e_string;
      case 28:    C_array_e_Object            e_c_array_e_Object;
      case 30:    C_array_e_TypeCode          e_c_array_e_TypeCode;
   };

   union Ext_F_union switch (long)
   {
      case 0:   Ext_C_struct              ext_e_c_struct;
      case 1:   Ext_C_union               ext_e_c_union;
      case 2:   C_sequence_e_longLong     e_c_sequence_e_longLong;
      case 3:   C_sequence_e_ulongLong    e_c_sequence_e_ulongLong;
      #ifndef LONG_DOUBLE_PROBLEM    
      case 4:   C_array_e_longDouble      e_c_array_e_long_double;
      case 5:   C_sequence_e_longDouble   e_c_sequence_e_longDouble;
      #endif
      case 6:   C_sequence_e_wchar        e_c_sequence_e_wchar;
      case 7:   C_sequence_e_wstring      e_c_sequence_e_wstring;
      case 8:   C_array_e_longLong        e_c_array_e_longLong;
      case 9:   C_array_e_ulongLong       e_c_array_e_ulongLong;
      case 10:  C_array_e_wchar           e_c_array_e_wchar;
      case 11:  C_array_e_wstring         e_c_array_e_wstring;
   };

   typedef sequence<C_struct>              F_sequence_e_c_struct;
   typedef sequence<Ext_C_struct>          F_sequence_e_ext_c_struct;
   typedef sequence<C_union>               F_sequence_e_c_union;
   typedef sequence<Ext_C_union>           F_sequence_e_ext_c_union;
   

   typedef C_struct                        F_array_e_c_struct[2];
   typedef Ext_C_struct                    F_array_e_ext_c_struct[2];
   typedef C_union                         F_array_e_c_union[2];
   typedef Ext_C_union                     F_array_e_ext_c_union[2];


   // G

   struct G_struct 
   {
      E_struct    e_e_struct;
      E_union     e_e_union;
      E_sequence  e_e_sequence;
      E_array     e_e_array;
   };

   union G_union switch (long) 
   {
      case 1: E_struct       e_e_struct;
      case 2: E_union        e_e_union;
      case 3: E_sequence     e_e_sequence;
      case 4: E_array        e_e_array;
   };

   typedef sequence<E_struct> G_sequence_e_e_struct;
   typedef sequence<E_union> G_sequence_e_e_union;

   typedef E_struct G_array_e_e_struct[2];
   typedef E_union G_array_e_e_union[2];


   // H : sequences of sequences - mixture of bounded and unbouded sequences
   typedef sequence<C_sequence_e_short>        H_seq_sequence_e_short;
   typedef sequence<C_sequence_e_ushort_10>    H_seq_sequence_e_ushort_10;
   typedef sequence<C_sequence_e_long, 10>     H_seq_10_sequence_e_long;
   typedef sequence<C_sequence_e_ulong_10, 10>   H_seq_10_sequence_e_ulong_10;
   typedef sequence<C_sequence_e_float>        H_seq_sequence_e_float;
   typedef sequence<C_sequence_e_double_10>    H_seq_sequence_e_double_10;
   typedef sequence<C_sequence_e_char, 10>     H_seq_10_sequence_e_char;
   typedef sequence<C_sequence_e_boolean_10, 10>   H_seq_10_sequence_e_boolean_10;
   typedef sequence<C_sequence_e_octet>        H_seq_sequence_e_octet;
   typedef sequence<C_sequence_e_any_10>       H_seq_sequence_e_any_10;
   typedef sequence<C_sequence_e_string, 10>   H_seq_10_sequence_e_string;
   typedef sequence<C_sequence_e_Object_10, 10>  H_seq_10_sequence_e_Object_10;
   typedef sequence<C_sequence_e_TypeCode>     H_seq_sequence_e_TypeCode;
   typedef sequence<C_sequence_e_longLong>     H_seq_sequence_e_longLong;
   typedef sequence<C_sequence_e_ulongLong>    H_seq_sequence_e_ulongLong;

   // H : sequences of arrays
   typedef sequence<C_array_e_short>           H_seq_array_e_short;
   typedef sequence<C_array_e_ushort>          H_seq_array_e_ushort;
   typedef sequence<C_array_e_long>            H_seq_array_e_long;
   typedef sequence<C_array_e_ulong>           H_seq_array_e_ulong;
   typedef sequence<C_array_e_float>           H_seq_array_e_float;
   typedef sequence<C_array_e_double>          H_seq_array_e_double;
   typedef sequence<C_array_e_char>            H_seq_array_e_char;
   typedef sequence<C_array_e_string>          H_seq_array_e_string;
   typedef sequence<C_array_e_Object>          H_seq_array_e_Object;
   typedef sequence<C_array_e_TypeCode>        H_seq_array_e_TypeCode;
   typedef sequence<C_array_e_longLong>        H_seq_array_e_LongLong;
   typedef sequence<C_array_e_ulongLong>       H_seq_array_e_ulongLong;
   
   


   /*------------------------------*/
   /* exceptional data definitions */
   /*------------------------------*/

   // A
   exception A_except1 
   {
      short v1;
      unsigned short v2;
      long v3;
      unsigned long v4;
      float v5;
      double v6;
      char v7;
      boolean v8;
      octet v9;
   };

   exception A_except2 
   {
      any v10;
      string v11;
      Object v12;
      CORBA::TypeCode v14;
   };

   // B
   exception B_except 
   { 
      B v;
   };

   // C
   exception C_except 
   {
      C_struct v1;
      C_union v2; // short
      C_union v3; // ushort
      C_union v4; // long
      C_union v5; // ulong
      C_union v6; // float
      C_union v7; // double
      C_union v8; // char
      C_union v9; // boolean
      C_union v10; // octet
      C_union v11; // any
      C_union v12; // string
      C_union v13; // Object
      C_union v15; // TypeCode
      C_sequence_e_short v16;
      C_sequence_e_ushort v17;
      C_sequence_e_long v18;
      C_sequence_e_ulong v19;
      C_sequence_e_float v20;
      C_sequence_e_double v21;
      C_sequence_e_char v22;
      C_sequence_e_boolean v23;
      C_sequence_e_octet v24;
      C_sequence_e_any v25;
      C_sequence_e_string v26;
      C_sequence_e_Object v27;
      C_sequence_e_TypeCode v29;
      C_array_e_short v30;
      C_array_e_ushort v31;
      C_array_e_long v32;
      C_array_e_ulong v33;
      C_array_e_float v34;
      C_array_e_double v35;
      C_array_e_char v36;
      C_array_e_boolean v37;
      C_array_e_octet v38;
      C_array_e_any v39;
      C_array_e_string v40;
      C_array_e_Object v41;
      C_array_e_TypeCode v43;
   };

   // D
   exception D_except 
   {
      D_d_short v1;
      D_d_ushort v2;
      D_d_long v3;
      D_d_ulong v4;
      D_d_char v5;
      D_d_boolean v6;
      D_d_B v7;
   };

   // E
   exception E_except 
   {
      E_struct v1;
      E_union v2;
      E_sequence v3;
      E_array v4;
   };

   // F
   exception F_except1 
   {
      F_struct v1;
      F_union v2; // C_struct
      F_union v3; // C_union
      F_union v4; // C_sequence_e_short
      F_union v5; // C_sequence_e_ushort
      F_union v6; // C_sequence_e_long
      F_union v7; // C_sequence_e_ulong
      F_union v8; // C_sequence e_float
      F_union v9; // C_sequence_e_double
      F_union v10; // C_sequence_e_char
      F_union v11; // C_sequence_e_boolean
      F_union v12; // C_sequence_e_octet
      F_union v13; // C_sequence_e_any
      F_union v14; // C_sequence_e_string
      F_union v15; // C_sequence_e_Object
      F_union v17; // C_sequence_e_TypeCode
      F_union v18; // C_array_e_short
      F_union v19; // C_array_e_ushort
      F_union v20; // C_array_e_long
      F_union v21; // C_array_e_ulong
      F_union v22; // C_array e_float
      F_union v23; // C_array_e_double
      F_union v24; // C_array_e_char
      F_union v25; // C_array_e_boolean
      F_union v26; // C_array_e_octet
      F_union v27; // C_array_e_any
      F_union v28; // C_array_e_string
      F_union v29; // C_array_e_Object
      F_union v31; // C_array_e_TypeCode
   };

   exception F_except2 
   {
      F_sequence_e_c_struct v32;
      F_sequence_e_c_union v33;
   };

   exception F_except3 
   {
      F_array_e_c_struct v62;
      F_array_e_c_union v63;
   };

   // G
   exception G_except 
   {
      G_struct v1;
      G_union v2; // E_struct
      G_union v3; // E_union
      G_union v4; // E_sequence
      G_union v5; // E_array
      G_sequence_e_e_struct v6;
      G_sequence_e_e_union v7;
      G_array_e_e_struct v10;
      G_array_e_e_union v11;
   };

   /*-----------------------*/
   /* Complex Types         */
   /*-----------------------*/

   #ifndef FORWARD_DECLS_PROBLEM
   struct complex_struct;
   typedef sequence<complex_struct> seq_complex_struct;

   union complex_union;
   typedef sequence<complex_union> seq_complex_union;

   interface complex_interface;
   typedef sequence<complex_interface> seq_complex_interface;

   struct complex_struct
   {
      // complex_struct another_struct;
      // complex_union  another_union;
      seq_complex_struct seq_struct;
      // complex_interface another_interface;
   };

   union complex_union switch(long)
   {      
      case 0:   seq_complex_union seq_union;
      // case 1:   complex_struct another_stuct;
      // case 2:   complex_union another_union;
      // case 3:   complex_interface;
   };

   interface complex_interface
   {
      attribute complex_struct another_struct;
      attribute complex_union another_union;
      attribute seq_complex_interface seq_interface;
      attribute complex_interface another_interface;
   };
   #endif

   /*-----------------------*/
   /* interface definitions */
   /*-----------------------*/

   interface rf11
   {
      // A
      short op1(in short argin, out short argout, inout short arginout);
      unsigned short op2(in unsigned short argin, out unsigned short argout, 
                         inout unsigned short arginout);
      long op3(in long argin, out long argout, inout long arginout);
      unsigned long op4(in unsigned long argin, out unsigned long argout, 
                        inout unsigned long arginout);
      float op5(in float argin, out float argout, inout float arginout);
      double op6(in double argin, out double argout, inout double arginout);
      char op7(in char argin, out char argout, inout char arginout);
      boolean op8(in boolean argin, out boolean argout, inout boolean arginout);
      octet op9(in octet argin, out octet argout, inout octet arginout);
      any op10(in any argin, out any argout, inout any arginout);
      string op11(in string argin, out string argout, inout string arginout);
      Object op12(in Object argin, out Object argout, inout Object arginout);
      CORBA::TypeCode op13(in CORBA::TypeCode argin, 
                           out CORBA::TypeCode argout, 
                           inout CORBA::TypeCode arginout);

      long long op140(in long long argin, out long long argout, 
                      inout long long arginout); 
      unsigned long long op141(in unsigned long long argin,
                               out unsigned long long argout,
                               inout unsigned long long arginout);
      wchar op142(in wchar argin, out wchar argout, inout wchar arginout);
      wstring op143(in wstring argin, out wstring argout, 
                    inout wstring arginout);

      // B
      B op15(in B argin, out B argout, inout B arginout);

      // C
      C_struct op16(in C_struct argin, out C_struct argout, 
                    inout C_struct arginout);
      Ext_C_struct op144(in Ext_C_struct argin, out Ext_C_struct argout,
                         inout Ext_C_struct arginout);
      C_union op17(in C_union argin, out C_union argout, inout C_union arginout);
      Ext_C_union op145(in Ext_C_union argin, out Ext_C_union argout,
                        inout Ext_C_union arginout);

      C_sequence_e_short op18(in C_sequence_e_short argin, 
                              out C_sequence_e_short argout,
                              inout C_sequence_e_short arginout);
      C_sequence_e_ushort op19(in C_sequence_e_ushort argin, 
                               out C_sequence_e_ushort argout, 
                               inout C_sequence_e_ushort arginout);
      C_sequence_e_long op20(in C_sequence_e_long argin, 
                             out C_sequence_e_long argout, 
                             inout C_sequence_e_long arginout);
      C_sequence_e_ulong op21(in C_sequence_e_ulong argin, 
                              out C_sequence_e_ulong argout, 
                              inout C_sequence_e_ulong arginout);
      C_sequence_e_float op22(in C_sequence_e_float argin, 
                              out C_sequence_e_float argout, 
                              inout C_sequence_e_float arginout);
      C_sequence_e_double op23(in C_sequence_e_double argin, 
                               out C_sequence_e_double argout, 
                               inout C_sequence_e_double arginout);
      C_sequence_e_char op24(in C_sequence_e_char argin, 
                             out C_sequence_e_char argout, 
                             inout C_sequence_e_char arginout);
      C_sequence_e_boolean op25(in C_sequence_e_boolean argin, 
                                out C_sequence_e_boolean argout, 
                                inout C_sequence_e_boolean arginout);
      C_sequence_e_octet op26(in C_sequence_e_octet argin, 
                              out C_sequence_e_octet argout, 
                              inout C_sequence_e_octet arginout);
      C_sequence_e_any op27(in C_sequence_e_any argin, 
                            out C_sequence_e_any argout, 
                            inout C_sequence_e_any arginout);
      C_sequence_e_string op28(in C_sequence_e_string argin, 
                               out C_sequence_e_string argout, 
                               inout C_sequence_e_string arginout);
      C_sequence_e_Object op29(in C_sequence_e_Object argin, 
                               out C_sequence_e_Object argout, 
                               inout C_sequence_e_Object arginout);
      C_sequence_e_TypeCode op31(in C_sequence_e_TypeCode argin, 
                                 out C_sequence_e_TypeCode argout, 
                                 inout C_sequence_e_TypeCode arginout);
      C_sequence_e_longLong op146(in C_sequence_e_longLong argin,
                                  out C_sequence_e_longLong argout,
                                  inout C_sequence_e_longLong arginout);

      /* FIXME: Next 2 methods are for debugging - remove */
      /*
      C_sequence_e_longLong op146_1(in C_sequence_e_longLong argin,
                                  out C_sequence_e_longLong argout);
      void op146_2(inout C_sequence_e_longLong arginout);
      */
      /* ---------------------------------------------------------------- */
      C_sequence_e_ulongLong op147(in C_sequence_e_ulongLong argin,
                                   out C_sequence_e_ulongLong argout,
                                   inout C_sequence_e_ulongLong arginout);
      C_sequence_e_wchar op148(in C_sequence_e_wchar argin, 
                               out C_sequence_e_wchar argout,
                               inout C_sequence_e_wchar arginout);
      C_sequence_e_wstring op149(in C_sequence_e_wstring argin,
                                 out C_sequence_e_wstring argout,
                                 inout C_sequence_e_wstring arginout);

      C_array_e_short op32(in C_array_e_short argin, 
                           out C_array_e_short argout, 
                           inout C_array_e_short arginout);
      C_array_e_ushort op33(in C_array_e_ushort argin, 
                            out C_array_e_ushort argout, 
                            inout C_array_e_ushort arginout);
      C_array_e_long op34(in C_array_e_long argin, 
                          out C_array_e_long argout, 
                          inout C_array_e_long arginout);
      C_array_e_ulong op35(in C_array_e_ulong argin, 
                           out C_array_e_ulong argout, 
                           inout C_array_e_ulong arginout);
      C_array_e_float op36(in C_array_e_float argin, 
                           out C_array_e_float argout, 
                           inout C_array_e_float arginout);
      C_array_e_double op37(in C_array_e_double argin, 
                            out C_array_e_double argout, 
                            inout C_array_e_double arginout);
      C_array_e_char op38(in C_array_e_char argin, 
                          out C_array_e_char argout, 
                          inout C_array_e_char arginout);
      C_array_e_boolean op39(in C_array_e_boolean argin, 
                             out C_array_e_boolean argout, 
                             inout C_array_e_boolean arginout);
      C_array_e_octet op40(in C_array_e_octet argin, 
                           out C_array_e_octet argout, 
                           inout C_array_e_octet arginout);
      C_array_e_any op41(in C_array_e_any argin, 
                         out C_array_e_any argout, 
                         inout C_array_e_any arginout);
      C_array_e_string op42(in C_array_e_string argin, 
                            out C_array_e_string argout, 
                            inout C_array_e_string arginout);
      C_array_e_Object op43(in C_array_e_Object argin, 
                            out C_array_e_Object argout, 
                            inout C_array_e_Object arginout);
      C_array_e_TypeCode op45(in C_array_e_TypeCode argin, 
                              out C_array_e_TypeCode argout, 
                              inout C_array_e_TypeCode arginout);

      // D
      D_d_short op46(in D_d_short argin, out D_d_short argout, 
                     inout D_d_short arginout);
      D_d_ushort op47(in D_d_ushort argin, out D_d_ushort argout, 
                      inout D_d_ushort arginout);
      D_d_long op48(in D_d_long argin, out D_d_long argout, 
                    inout D_d_long arginout);
      D_d_ulong op49(in D_d_ulong argin, out D_d_ulong argout, 
                     inout D_d_ulong arginout);
      D_d_char op50(in D_d_char argin, out D_d_char argout, 
                    inout D_d_char arginout);
      D_d_boolean op51(in D_d_boolean argin, out D_d_boolean argout, 
                       inout D_d_boolean arginout);
      D_d_B op52(in D_d_B argin, out D_d_B argout, inout D_d_B arginout);

      // E
      E_struct op53(in E_struct argin, out E_struct argout, 
                    inout E_struct arginout);
      E_union op54(in E_union argin, out E_union argout, inout E_union arginout);
      E_sequence op55(in E_sequence argin, out E_sequence argout, 
                      inout E_sequence arginout);
      E_array op56(in E_array argin, out E_array argout, 
                   inout E_array arginout);

      // F
      F_struct op57(in F_struct argin, out F_struct argout, 
                    inout F_struct arginout);
      F_union op58(in F_union argin, out F_union argout, inout F_union arginout);
      F_sequence_e_c_struct op59(in F_sequence_e_c_struct argin,
                                 out F_sequence_e_c_struct argout, 
                                 inout F_sequence_e_c_struct arginout);
      F_sequence_e_c_union op60(in F_sequence_e_c_union argin, 
                                out F_sequence_e_c_union argout, 
                                inout F_sequence_e_c_union arginout);
      F_array_e_c_struct op89(in F_array_e_c_struct argin, 
                              out F_array_e_c_struct argout, 
                              inout F_array_e_c_struct arginout);
      F_array_e_c_union op90(in F_array_e_c_union argin, 
                             out F_array_e_c_union argout, 
                             inout F_array_e_c_union arginout);

      // G
      G_struct op119(in G_struct argin, out G_struct argout, 
                     inout G_struct arginout);
      G_union op120(in G_union argin, out G_union argout, inout G_union arginout);
      G_sequence_e_e_struct op121(in G_sequence_e_e_struct argin, 
                                  out G_sequence_e_e_struct argout, 
                                  inout G_sequence_e_e_struct arginout);
      G_sequence_e_e_union op122(in G_sequence_e_e_union argin, 
                                 out G_sequence_e_e_union argout, 
                                 inout G_sequence_e_e_union arginout);
      G_array_e_e_struct op125(in G_array_e_e_struct argin, 
                               out G_array_e_e_struct argout, 
                               inout G_array_e_e_struct arginout);
      G_array_e_e_union op126(in G_array_e_e_union argin, 
                              out G_array_e_e_union argout, 
                              inout G_array_e_e_union arginout);

      // rest of F
      F_union op129(in F_union argin, out F_union argout, inout F_union arginout);
      F_union op130(in F_union argin, out F_union argout, inout F_union arginout);
      F_union op131(in F_union argin, out F_union argout, inout F_union arginout);

      // exception
      // pragma: exception=A_except1
      void excop1() raises(A_except1);
      // pragma: exception=A_except2
      void excop2() raises(A_except2);
      // pragma: exception=B_except
      void excop3() raises(B_except);
      // pragma: exception=C_except
      void excop4() raises(C_except);
      // pragma: exception=D_except
      void excop5() raises(D_except);
      // pragma: exception=E_except
      void excop6() raises(E_except);
      // pragma: exception=F_except1
      void excop7() raises(F_except1);
      // pragma: exception=F_except2
      void excop8() raises(F_except2);
      // pragma: exception=F_except3
      void excop9() raises(F_except3);
      // pragma: exception=G_except
      void excop10() raises(G_except);

      // Complex Types
      /*
      complex_struct complexOp1( in complex_struct complex_in, 
                                 out complex_struct complex_out, 
                                 inout complex_struct complex_inout );
      complex_union complexOp2( in complex_union complex_in,
                                out complex_union complex_out,
                                inout complex_union complex_inout );
      complex_interface complexOp3( in complex_interface complex_in,
                                    out complex_interface complex_out,
                                    inout complex_interface complex_inout );
      */
   };


   /*-------------------------*/
   /* Sequence Types          */
   /*-------------------------*/
   
   // Test 1: Sequences of long.
   
   interface Echo {
      string echoString(in string mesg);
   };

   typedef sequence <long> seq_long;
   typedef sequence<sequence<long> > seqseq_long;
   typedef sequence<sequence<sequence<long> > > seqseqseq_long;

   typedef sequence <long,10> seq_long_10;
   typedef sequence <seq_long_10, 10> seqseq_long_10;
   typedef sequence <seqseq_long_10, 10> seqseqseq_long_10;


   interface Exercise1 {
      seq_long dump_seq_long(in seq_long a1, 
                             inout seq_long a2, 
                             out seq_long a3);
      seqseq_long dump_seqseq_long(in seqseq_long a1, 
                                   inout seqseq_long a2, 
                                   out seqseq_long a3);
      seqseqseq_long dump_seqseqseq_long(in seqseqseq_long a1, 
                                         inout seqseqseq_long a2, 
                                         out seqseqseq_long a3);

      seq_long_10 dump_seq_long_10(in seq_long_10 a1, 
                                   inout seq_long_10 a2, 
                                   out seq_long_10 a3);
      seqseq_long_10 dump_seqseq_long_10(in seqseq_long_10 a1, 
                                            inout seqseq_long_10 a2, 
                                            out seqseq_long_10 a3);
      seqseqseq_long_10 
         dump_seqseqseq_long_10(in seqseqseq_long_10 a1, 
                                inout seqseqseq_long_10 a2, 
                                out seqseqseq_long_10 a3);
   };


   // Test 2: seqeunces of strings

   typedef sequence <string> seq_string;
   typedef sequence<sequence<string> > seqseq_string;
   typedef sequence<sequence<sequence<string> > > seqseqseq_string;

   typedef sequence <string,10> seq_string_10;
   typedef sequence <seq_string_10, 10> seqseq_string_10;
   typedef sequence <seqseq_string_10, 10> seqseqseq_string_10;

   interface Exercise2 {
      seq_string dump_seq_string(in seq_string a1, 
                                 inout seq_string a2, 
                                 out seq_string a3);
      seqseq_string dump_seqseq_string(in seqseq_string a1, 
                                       inout seqseq_string a2, 
                                       out seqseq_string a3);
      seqseqseq_string dump_seqseqseq_string(in seqseqseq_string a1, 
                                             inout seqseqseq_string a2, 
                                             out seqseqseq_string a3);

      seq_string_10 dump_seq_string_10(in seq_string_10 a1, 
                                       inout seq_string_10 a2, 
                                       out seq_string_10 a3);
      seqseq_string_10 dump_seqseq_string_10(in seqseq_string_10 a1, 
                                                inout seqseq_string_10 a2, 
                                                out seqseq_string_10 a3);
      seqseqseq_string_10 
         dump_seqseqseq_string_10(in seqseqseq_string_10 a1, 
                                  inout seqseqseq_string_10 a2, 
                                  out seqseqseq_string_10 a3);
   };

   // Test 3: sequences of interface Echo.

   typedef sequence <Echo> seq_echo;
   typedef sequence <sequence<Echo> > seqseq_echo;
   typedef sequence <sequence<sequence<Echo> > > seqseqseq_echo;
   
   typedef sequence <Echo,10> seq_echo_10;
   typedef sequence <seq_echo_10, 10> seqseq_echo_10_10;
   typedef sequence <seqseq_echo_10_10, 10> seqseq_echo_10_10_10;
   
   interface Exercise3 {
      seq_echo dump_seq_echo(in seq_echo a1, 
                             inout seq_echo a2,
                             out seq_echo a3);
      seqseq_echo dump_seqseq_echo(in seqseq_echo a1, 
                                   inout seqseq_echo a2, 
                                   out seqseq_echo a3);
      seqseqseq_echo dump_seqseqseq_echo(in seqseqseq_echo a1, 
                                         inout seqseqseq_echo a2,
                                         out seqseqseq_echo a3);
      
      seq_echo_10 dump_seq_echo_10(in seq_echo_10 a1, 
                                   inout seq_echo_10 a2,
                                   out seq_echo_10 a3);
      seqseq_echo_10_10 dump_seqseq_echo_10(in seqseq_echo_10_10 a1, 
                                            inout seqseq_echo_10_10 a2,
                                            out seqseq_echo_10_10 a3);
      seqseq_echo_10_10_10 
         dump_seqseqseq_echo_10(in seqseq_echo_10_10_10 a1, 
                                inout seqseq_echo_10_10_10 a2, 
                                out seqseq_echo_10_10_10 a3);
   };

   // Test 4: sequences of arrays of doubles.

   typedef double arr_double[10];
   typedef arr_double arrarr_double[100];
   
   typedef sequence <arr_double> seq_arr_double;
   typedef sequence <sequence<arr_double> > seqseq_arr_double;
   typedef sequence <sequence<sequence<arr_double> > > seqseqseq_arr_double;

   typedef sequence <arr_double,10> seq_arr_double_10;
   typedef sequence <seq_arr_double_10, 10> seq_arr_double_10_10;
   typedef sequence <seq_arr_double_10_10, 10> seq_arr_double_10_10_10;

   typedef sequence <arrarr_double> seq_arrarr_double;
   typedef sequence <sequence<arrarr_double> > seqseq_arrarr_double;
   typedef sequence <sequence<sequence<arrarr_double> > > seqseqseq_arrarr_double;

   typedef sequence <arrarr_double,10> seq_arrarr_double_10;
   typedef sequence <seq_arrarr_double_10, 10> seq_arrarr_double_10_10;
   typedef sequence <seq_arrarr_double_10_10, 10> seq_arrarr_double_10_10_10;

   interface Exercise4 {
      seq_arr_double dump_seq_arr_double(in seq_arr_double a1, 
                                         inout seq_arr_double a2, 
                                         out seq_arr_double a3);
      seqseq_arr_double dump_seqseq_arr_double(in seqseq_arr_double a1, 
                                               inout seqseq_arr_double a2, 
                                               out seqseq_arr_double a3);
      seqseqseq_arr_double 
         dump_seqseqseq_arr_double(in seqseqseq_arr_double a1, 
                                   inout seqseqseq_arr_double a2, 
                                   out seqseqseq_arr_double a3);

      seq_arr_double_10 dump_seq_arr_double_10(in seq_arr_double_10 a1, 
                                               inout seq_arr_double_10 a2, 
                                               out seq_arr_double_10 a3);
      seq_arr_double_10_10 
         dump_seq_arr_double_10_10(in seq_arr_double_10_10 a1, 
                                   inout seq_arr_double_10_10 a2, 
                                   out seq_arr_double_10_10 a3);
      seq_arr_double_10_10_10 
         dump_seq_arr_double_10_10_10(in seq_arr_double_10_10_10 a1, 
                                      inout seq_arr_double_10_10_10 a2, 
                                      out seq_arr_double_10_10_10 a3);

      seq_arrarr_double dump_seq_arrarr_double(in seq_arrarr_double a1, 
                                               inout seq_arrarr_double a2, 
                                               out seq_arrarr_double a3);
      seqseq_arrarr_double
         dump_seqseq_arrarr_double(in seqseq_arrarr_double a1, 
                                   inout seqseq_arrarr_double a2, 
                                   out seqseq_arrarr_double a3);
      seqseqseq_arrarr_double 
         dump_seqseqseq_arrarr_double(in seqseqseq_arrarr_double a1, 
                                      inout seqseqseq_arrarr_double a2, 
                                      out seqseqseq_arrarr_double a3);

      seq_arrarr_double_10 
         dump_seq_arrarr_double_10(in seq_arrarr_double_10 a1, 
                                   inout seq_arrarr_double_10 a2, 
                                   out seq_arrarr_double_10 a3);
      seq_arrarr_double_10_10 
         dump_seq_arrarr_double_10_10(in seq_arrarr_double_10_10 a1, 
                                      inout seq_arrarr_double_10_10 a2, 
                                      out seq_arrarr_double_10_10 a3);
      seq_arrarr_double_10_10_10 
         dump_seq_arrarr_double_10_10_10(in seq_arrarr_double_10_10_10 a1, 
                                         inout seq_arrarr_double_10_10_10 a2, 
                                         out seq_arrarr_double_10_10_10 a3);
   };

   
   // Test 5: sequences of arrays of strings

   typedef string arr_string[4];
   typedef string arrarr_string[4][8];

   typedef sequence <arr_string> seq_arr_string;
   typedef sequence <sequence<arr_string> > seqseq_arr_string;
   typedef sequence <sequence<sequence<arr_string> > > seqseqseq_arr_string;

   typedef sequence <arr_string,10> seq_arr_string_10;
   typedef sequence <seq_arr_string_10,10> seq_arr_string_10_10;
   typedef sequence <seq_arr_string_10_10,10> seq_arr_string_10_10_10;
   
   typedef sequence <arrarr_string> seq_arrarr_string;
   typedef sequence <sequence<arrarr_string> > seqseq_arrarr_string;
   typedef sequence <sequence<sequence<arrarr_string> > > seqseqseq_arrarr_string;

   typedef sequence <arrarr_string,10> seq_arrarr_string_10;
   typedef sequence <seq_arrarr_string_10,10> seq_arrarr_string_10_10;
   typedef sequence <seq_arrarr_string_10_10,10> seq_arrarr_string_10_10_10;

   interface Exercise5 {
      seq_arr_string dump_seq_arr_string(in seq_arr_string a1, 
                                         inout seq_arr_string a2, 
                                         out seq_arr_string a3);
      seqseq_arr_string dump_seqseq_arr_string(in seqseq_arr_string a1, 
                                               inout seqseq_arr_string a2, 
                                               out seqseq_arr_string a3);
      seqseqseq_arr_string 
         dump_seqseqseq_arr_string(in seqseqseq_arr_string a1, 
                                   inout seqseqseq_arr_string a2, 
                                   out seqseqseq_arr_string a3);

      seq_arr_string_10 dump_seq_arr_string_10(in seq_arr_string_10 a1, 
                                               inout seq_arr_string_10 a2, 
                                               out seq_arr_string_10 a3);
      seq_arr_string_10_10 
         dump_seq_arr_string_10_10(in seq_arr_string_10_10 a1, 
                                   inout seq_arr_string_10_10 a2, 
                                   out seq_arr_string_10_10 a3);
      seq_arr_string_10_10_10 
         dump_seq_arr_string_10_10_10(in seq_arr_string_10_10_10 a1, 
                                      inout seq_arr_string_10_10_10 a2, 
                                      out seq_arr_string_10_10_10 a3);

      seq_arrarr_string 
         dump_seq_arrarr_string(in seq_arrarr_string a1, 
                                inout seq_arrarr_string a2, 
                                out seq_arrarr_string a3);
      seqseq_arrarr_string 
         dump_seqseq_arrarr_string(in seqseq_arrarr_string a1, 
                                   inout seqseq_arrarr_string a2, 
                                   out seqseq_arrarr_string a3);
      seqseqseq_arrarr_string 
         dump_seqseqseq_arrarr_string(in seqseqseq_arrarr_string a1, 
                                      inout seqseqseq_arrarr_string a2, 
                                      out seqseqseq_arrarr_string a3);

      seq_arrarr_string_10 
         dump_seq_arrarr_string_10(in seq_arrarr_string_10 a1, 
                                   inout seq_arrarr_string_10 a2, 
                                   out seq_arrarr_string_10 a3);
      seq_arrarr_string_10_10 
         dump_seq_arrarr_string_10_10(in seq_arrarr_string_10_10 a1, 
                                      inout seq_arrarr_string_10_10 a2, 
                                      out seq_arrarr_string_10_10 a3);
      seq_arrarr_string_10_10_10 
         dump_seq_arrarr_string_10_10_10(in seq_arrarr_string_10_10_10 a1, 
                                         inout seq_arrarr_string_10_10_10 a2, 
                                         out seq_arrarr_string_10_10_10 a3);

   };


   // Test 6: sequences of arrays of interface Echo
   
   typedef Echo arr_Echo[13];
   typedef Echo arrarr_Echo[3][83];

   typedef sequence <arr_Echo> seq_arr_Echo;
   typedef sequence <sequence<arr_Echo> > seqseq_arr_Echo;
   typedef sequence <sequence<sequence<arr_Echo> > > seqseqseq_arr_Echo;

   typedef sequence <arr_Echo,10> seq_arr_Echo_10;
   typedef sequence <seq_arr_Echo_10, 10> seq_arr_Echo_10_10;
   typedef sequence <seq_arr_Echo_10_10, 10> seq_arr_Echo_10_10_10;

   typedef sequence <arrarr_Echo> seq_arrarr_Echo;
   typedef sequence <sequence<arrarr_Echo> > seqseq_arrarr_Echo;
   typedef sequence <sequence<sequence<arrarr_Echo> > > seqseqseq_arrarr_Echo;

   typedef sequence <arrarr_Echo,10> seq_arrarr_Echo_10;
   typedef sequence <seq_arrarr_Echo_10, 10> seq_arrarr_Echo_10_10;
   typedef sequence <seq_arrarr_Echo_10_10, 10> seq_arrarr_Echo_10_10_10;

   interface Exercise6 {
      seq_arr_Echo dump_seq_arr_Echo(in seq_arr_Echo a1, 
                                     inout seq_arr_Echo a2, 
                                     out seq_arr_Echo a3);
      seqseq_arr_Echo dump_seqseq_arr_Echo(in seqseq_arr_Echo a1, 
                                           inout seqseq_arr_Echo a2, 
                                           out seqseq_arr_Echo a3);
      seqseqseq_arr_Echo dump_seqseqseq_arr_Echo(in seqseqseq_arr_Echo a1, 
                                                 inout seqseqseq_arr_Echo a2, 
                                                 out seqseqseq_arr_Echo a3);
      
      seq_arr_Echo_10 dump_seq_arr_Echo_10(in seq_arr_Echo_10 a1, 
                                           inout seq_arr_Echo_10 a2, 
                                           out seq_arr_Echo_10 a3);
      seq_arr_Echo_10_10 dump_seq_arr_Echo_10_10(in seq_arr_Echo_10_10 a1, 
                                                 inout seq_arr_Echo_10_10 a2, 
                                                 out seq_arr_Echo_10_10 a3);
      seq_arr_Echo_10_10_10 
         dump_seq_arr_Echo_10_10_10(in seq_arr_Echo_10_10_10 a1, 
                                    inout seq_arr_Echo_10_10_10 a2, 
                                    out seq_arr_Echo_10_10_10 a3);
      
      seq_arrarr_Echo dump_seq_arrarr_Echo(in seq_arrarr_Echo a1, 
                                           inout seq_arrarr_Echo a2, 
                                           out seq_arrarr_Echo a3);
      seqseq_arrarr_Echo dump_seqseq_arrarr_Echo(in seqseq_arrarr_Echo a1, 
                                                 inout seqseq_arrarr_Echo a2, 
                                                 out seqseq_arrarr_Echo a3);
      seqseqseq_arrarr_Echo 
         dump_seqseqseq_arrarr_Echo(in seqseqseq_arrarr_Echo a1, 
                                    inout seqseqseq_arrarr_Echo a2, 
                                    out seqseqseq_arrarr_Echo a3);
      
      seq_arrarr_Echo_10 dump_seq_arrarr_Echo_10(in seq_arrarr_Echo_10 a1, 
                                                 inout seq_arrarr_Echo_10 a2, 
                                                 out seq_arrarr_Echo_10 a3);
      seq_arrarr_Echo_10_10 
         dump_seq_arrarr_Echo_10_10(in seq_arrarr_Echo_10_10 a1, 
                                    inout seq_arrarr_Echo_10_10 a2, 
                                    out seq_arrarr_Echo_10_10 a3);
      seq_arrarr_Echo_10_10_10 
         dump_seq_arrarr_Echo_10_10_10(in seq_arrarr_Echo_10_10_10 a1, 
                                       inout seq_arrarr_Echo_10_10_10 a2, 
                                       out seq_arrarr_Echo_10_10_10 a3);
   };

   // Test 7: sequences of fixed size struct.

   struct sFixed {
      long s1;
   };

   
   typedef sFixed arr_sFixed[4];
   typedef sFixed arrarr_sFixed[4][8];
   
   typedef sequence <arr_sFixed> seq_arr_sFixed;
   typedef sequence <sequence<arr_sFixed> > seqseq_arr_sFixed;
   typedef sequence <sequence<sequence<arr_sFixed> > > seqseqseq_arr_sFixed;
   
   typedef sequence <arr_sFixed,10> seq_arr_sFixed_10;
   typedef sequence <seq_arr_sFixed_10, 10> seq_arr_sFixed_10_10;
   typedef sequence <seq_arr_sFixed_10_10, 10> seq_arr_sFixed_10_10_10;
   
   typedef sequence <arrarr_sFixed> seq_arrarr_sFixed;
   typedef sequence <sequence<arrarr_sFixed> > seqseq_arrarr_sFixed;
   typedef sequence <sequence<sequence<arrarr_sFixed> > > seqseqseq_arrarr_sFixed;
   
   typedef sequence <arrarr_sFixed,10> seq_arrarr_sFixed_10;
   typedef sequence <seq_arrarr_sFixed_10, 10> seq_arrarr_sFixed_10_10;
   typedef sequence <seq_arrarr_sFixed_10_10, 10> seq_arrarr_sFixed_10_10_10;

   
   interface Exercise7 {
      seq_arr_sFixed dump_seq_arr_sFixed(in seq_arr_sFixed a1, 
                                         inout seq_arr_sFixed a2, 
                                         out seq_arr_sFixed a3);
      seqseq_arr_sFixed dump_seqseq_arr_sFixed(in seqseq_arr_sFixed a1, 
                                               inout seqseq_arr_sFixed a2, 
                                               out seqseq_arr_sFixed a3);
      seqseqseq_arr_sFixed
         dump_seqseqseq_arr_sFixed(in seqseqseq_arr_sFixed a1, 
                                   inout seqseqseq_arr_sFixed a2, 
                                   out seqseqseq_arr_sFixed a3);

      seq_arr_sFixed_10 dump_seq_arr_sFixed_10(in seq_arr_sFixed_10 a1, 
                                               inout seq_arr_sFixed_10 a2, 
                                               out seq_arr_sFixed_10 a3);
      seq_arr_sFixed_10_10 
         dump_seq_arr_sFixed_10_10(in seq_arr_sFixed_10_10 a1, 
                                   inout seq_arr_sFixed_10_10 a2, 
                                   out seq_arr_sFixed_10_10 a3);
      seq_arr_sFixed_10_10_10 
         dump_seq_arr_sFixed_10_10_10(in seq_arr_sFixed_10_10_10 a1, 
                                      inout seq_arr_sFixed_10_10_10 a2, 
                                      out seq_arr_sFixed_10_10_10 a3);

      seq_arrarr_sFixed dump_seq_arrarr_sFixed(in seq_arrarr_sFixed a1, 
                                               inout seq_arrarr_sFixed a2, 
                                               out seq_arrarr_sFixed a3);
      seqseq_arrarr_sFixed 
         dump_seqseq_arrarr_sFixed(in seqseq_arrarr_sFixed a1, 
                                   inout seqseq_arrarr_sFixed a2, 
                                   out seqseq_arrarr_sFixed a3);
      seqseqseq_arrarr_sFixed 
         dump_seqseqseq_arrarr_sFixed(in seqseqseq_arrarr_sFixed a1, 
                                      inout seqseqseq_arrarr_sFixed a2, 
                                      out seqseqseq_arrarr_sFixed a3);

      seq_arrarr_sFixed_10 
         dump_seq_arrarr_sFixed_10(in seq_arrarr_sFixed_10 a1, 
                                   inout seq_arrarr_sFixed_10 a2, 
                                   out seq_arrarr_sFixed_10 a3);
      seq_arrarr_sFixed_10_10 
         dump_seq_arrarr_sFixed_10_10(in seq_arrarr_sFixed_10_10 a1, 
                                      inout seq_arrarr_sFixed_10_10 a2, 
                                      out seq_arrarr_sFixed_10_10 a3);
      seq_arrarr_sFixed_10_10_10 
         dump_seq_arrarr_sFixed_10_10_10(in seq_arrarr_sFixed_10_10_10 a1, 
                                         inout seq_arrarr_sFixed_10_10_10 a2, 
                                         out seq_arrarr_sFixed_10_10_10 a3);
   };


   // Test 8: sequences of variable length structs
   
   struct sVariable {
      string s1;
   };


   typedef sequence<sVariable > seq_sVariable;
   typedef sequence<sequence<sVariable > > seqseq_sVariable;
   typedef sequence<sequence<sequence<sVariable > > > seqseqseq_sVariable;

   typedef sVariable arr_sVariable[4];
   typedef sVariable arrarr_sVariable[4][8];

   typedef sequence <arr_sVariable> seq_arr_sVariable;
   typedef sequence <sequence<arr_sVariable> > seqseq_arr_sVariable;
   typedef sequence <sequence<sequence<arr_sVariable> > > seqseqseq_arr_sVariable;

   typedef sequence <arr_sVariable,10> seq_arr_sVariable_10;
   typedef sequence <seq_arr_sVariable_10,10> seq_arr_sVariable_10_10;
   typedef sequence <seq_arr_sVariable_10_10,10> seq_arr_sVariable_10_10_10;

   typedef sequence <arrarr_sVariable> seq_arrarr_sVariable;
   typedef sequence <sequence<arrarr_sVariable> > seqseq_arrarr_sVariable;
   typedef sequence <sequence<sequence<arrarr_sVariable> > > seqseqseq_arrarr_sVariable;

   typedef sequence <arrarr_sVariable,10> seq_arrarr_sVariable_10;
   typedef sequence <seq_arrarr_sVariable_10,10> seq_arrarr_sVariable_10_10;
   typedef sequence <seq_arrarr_sVariable_10_10,10> seq_arrarr_sVariable_10_10_10;

   
   interface Exercise8 {
      seq_arr_sVariable dump_seq_arr_sVariable(in seq_arr_sVariable a1, 
                                               inout seq_arr_sVariable a2, 
                                               out seq_arr_sVariable a3);
      seqseq_arr_sVariable 
         dump_seqseq_arr_sVariable(in seqseq_arr_sVariable a1, 
                                   inout seqseq_arr_sVariable a2, 
                                   out seqseq_arr_sVariable a3);
      seqseqseq_arr_sVariable 
         dump_seqseqseq_arr_sVariable(in seqseqseq_arr_sVariable a1, 
                                      inout seqseqseq_arr_sVariable a2, 
                                      out seqseqseq_arr_sVariable a3);

      seq_arr_sVariable_10 
         dump_seq_arr_sVariable_10(in seq_arr_sVariable_10 a1, 
                                   inout seq_arr_sVariable_10 a2, 
                                   out seq_arr_sVariable_10 a3);
      seq_arr_sVariable_10_10 
         dump_seq_arr_sVariable_10_10(in seq_arr_sVariable_10_10 a1, 
                                      inout seq_arr_sVariable_10_10 a2, 
                                      out seq_arr_sVariable_10_10 a3);
      seq_arr_sVariable_10_10_10 
         dump_seq_arr_sVariable_10_10_10(in seq_arr_sVariable_10_10_10 a1, 
                                         inout seq_arr_sVariable_10_10_10 a2, 
                                         out seq_arr_sVariable_10_10_10 a3);

      seq_arrarr_sVariable 
         dump_seq_arrarr_sVariable(in seq_arrarr_sVariable a1, 
                                   inout seq_arrarr_sVariable a2, 
                                   out seq_arrarr_sVariable a3);
      seqseq_arrarr_sVariable 
         dump_seqseq_arrarr_sVariable(in seqseq_arrarr_sVariable a1, 
                                      inout seqseq_arrarr_sVariable a2, 
                                      out seqseq_arrarr_sVariable a3);
      seqseqseq_arrarr_sVariable 
         dump_seqseqseq_arrarr_sVariable(in seqseqseq_arrarr_sVariable a1, 
                                         inout seqseqseq_arrarr_sVariable a2, 
                                         out seqseqseq_arrarr_sVariable a3);

      seq_arrarr_sVariable_10 
         dump_seq_arrarr_sVariable_10(in seq_arrarr_sVariable_10 a1, 
                                      inout seq_arrarr_sVariable_10 a2, 
                                      out seq_arrarr_sVariable_10 a3);
      seq_arrarr_sVariable_10_10 
         dump_seq_arrarr_sVariable_10_10(in seq_arrarr_sVariable_10_10 a1, 
                                         inout seq_arrarr_sVariable_10_10 a2, 
                                         out seq_arrarr_sVariable_10_10 a3);
      seq_arrarr_sVariable_10_10_10 
         dump_seq_arrarr_sVariable_10_10_10(in seq_arrarr_sVariable_10_10_10 a1, 
                                            inout seq_arrarr_sVariable_10_10_10 a2, 
                                            out seq_arrarr_sVariable_10_10_10 a3);

   };


   // Test 9: sequences of fixed length union

   typedef long longArray2d[20][20];

   union uFixed switch (long) {
      default:
         // long array[20][20];
         longArray2d array;
   };

   typedef uFixed arr_uFixed[4];
   typedef uFixed arrarr_uFixed[4][8];
   
   typedef sequence <arr_uFixed> seq_arr_uFixed;
   typedef sequence <sequence<arr_uFixed> > seqseq_arr_uFixed;
   typedef sequence <sequence<sequence<arr_uFixed> > > seqseqseq_arr_uFixed;
   
   typedef sequence <arr_uFixed,10> seq_arr_uFixed_10;
   typedef sequence <seq_arr_uFixed_10, 10> seq_arr_uFixed_10_10;
   typedef sequence <seq_arr_uFixed_10_10, 10> seq_arr_uFixed_10_10_10;
   
   typedef sequence <arrarr_uFixed> seq_arrarr_uFixed;
   typedef sequence <sequence<arrarr_uFixed> > seqseq_arrarr_uFixed;
   typedef sequence <sequence<sequence<arrarr_uFixed> > > seqseqseq_arrarr_uFixed;
   
   typedef sequence <arrarr_uFixed,10> seq_arrarr_uFixed_10;
   typedef sequence <seq_arrarr_uFixed_10,10> seq_arrarr_uFixed_10_10;
   typedef sequence <seq_arrarr_uFixed_10_10,10> seq_arrarr_uFixed_10_10_10;
   

   interface Exercise9 {
      seq_arr_uFixed dump_seq_arr_uFixed(in seq_arr_uFixed a1, 
                                         inout seq_arr_uFixed a2, 
                                         out seq_arr_uFixed a3);
      seqseq_arr_uFixed dump_seqseq_arr_uFixed(in seqseq_arr_uFixed a1, 
                                               inout seqseq_arr_uFixed a2, 
                                               out seqseq_arr_uFixed a3);
      seqseqseq_arr_uFixed
         dump_seqseqseq_arr_uFixed(in seqseqseq_arr_uFixed a1, 
                                   inout seqseqseq_arr_uFixed a2, 
                                   out seqseqseq_arr_uFixed a3);

      seq_arr_uFixed_10 dump_seq_arr_uFixed_10(in seq_arr_uFixed_10 a1, 
                                               inout seq_arr_uFixed_10 a2, 
                                               out seq_arr_uFixed_10 a3);
      seq_arr_uFixed_10_10
         dump_seq_arr_uFixed_10_10(in seq_arr_uFixed_10_10 a1, 
                                   inout seq_arr_uFixed_10_10 a2, 
                                   out seq_arr_uFixed_10_10 a3);
      seq_arr_uFixed_10_10_10 
         dump_seq_arr_uFixed_10_10_10(in seq_arr_uFixed_10_10_10 a1, 
                                      inout seq_arr_uFixed_10_10_10 a2, 
                                      out seq_arr_uFixed_10_10_10 a3);

      seq_arrarr_uFixed dump_seq_arrarr_uFixed(in seq_arrarr_uFixed a1, 
                                               inout seq_arrarr_uFixed a2, 
                                               out seq_arrarr_uFixed a3);
      seqseq_arrarr_uFixed
         dump_seqseq_arrarr_uFixed(in seqseq_arrarr_uFixed a1, 
                                   inout seqseq_arrarr_uFixed a2, 
                                   out seqseq_arrarr_uFixed a3);
      seqseqseq_arrarr_uFixed 
         dump_seqseqseq_arrarr_uFixed(in seqseqseq_arrarr_uFixed a1, 
                                      inout seqseqseq_arrarr_uFixed a2, 
                                      out seqseqseq_arrarr_uFixed a3);

      seq_arrarr_uFixed_10 
         dump_seq_arrarr_uFixed_10(in seq_arrarr_uFixed_10 a1, 
                                   inout seq_arrarr_uFixed_10 a2, 
                                   out seq_arrarr_uFixed_10 a3);
      seq_arrarr_uFixed_10_10 
         dump_seq_arrarr_uFixed_10_10(in seq_arrarr_uFixed_10_10 a1, 
                                      inout seq_arrarr_uFixed_10_10 a2, 
                                      out seq_arrarr_uFixed_10_10 a3);
      seq_arrarr_uFixed_10_10_10 
         dump_seq_arrarr_uFixed_10_10_10(in seq_arrarr_uFixed_10_10_10 a1, 
                                         inout seq_arrarr_uFixed_10_10_10 a2, 
                                         out seq_arrarr_uFixed_10_10_10 a3);
   };


   // Test 10: Sequences of variable length unions.

   union uVariable switch (char) {
      // case 0:   sFixed u;
      case 'b':    long v;
      case 'c':    sVariable w;
      case 'd':    uFixed  x;
   };

   typedef uVariable arr_uVariable[4];
   typedef uVariable arrarr_uVariable[4][8];
   
   typedef sequence <arr_uVariable> seq_arr_uVariable;
   typedef sequence <sequence<arr_uVariable> > seqseq_arr_uVariable;
   typedef sequence <sequence<sequence<arr_uVariable> > > seqseqseq_arr_uVariable;

   typedef sequence <arr_uVariable,10> seq_arr_uVariable_10;
   typedef sequence <seq_arr_uVariable_10,10> seq_arr_uVariable_10_10;
   typedef sequence <seq_arr_uVariable_10_10,10> seq_arr_uVariable_10_10_10;

   typedef sequence <arrarr_uVariable> seq_arrarr_uVariable;
   typedef sequence <sequence<arrarr_uVariable> > seqseq_arrarr_uVariable;
   typedef sequence <sequence<sequence<arrarr_uVariable> > > seqseqseq_arrarr_uVariable;

   typedef sequence <arrarr_uVariable,10> seq_arrarr_uVariable_10;
   typedef sequence <seq_arrarr_uVariable_10,10> seq_arrarr_uVariable_10_10;
   typedef sequence <seq_arrarr_uVariable_10_10,10> seq_arrarr_uVariable_10_10_10;


   interface Exercise10 {
      seq_arr_uVariable dump_seq_arr_uVariable(in seq_arr_uVariable a1, 
                                               inout seq_arr_uVariable a2, 
                                               out seq_arr_uVariable a3);
      seqseq_arr_uVariable 
         dump_seqseq_arr_uVariable(in seqseq_arr_uVariable a1, 
                                   inout seqseq_arr_uVariable a2, 
                                   out seqseq_arr_uVariable a3);
      seqseqseq_arr_uVariable
         dump_seqseqseq_arr_uVariable(in seqseqseq_arr_uVariable a1, 
                                      inout seqseqseq_arr_uVariable a2, 
                                      out seqseqseq_arr_uVariable a3);

      seq_arr_uVariable_10 
         dump_seq_arr_uVariable_10(in seq_arr_uVariable_10 a1, 
                                   inout seq_arr_uVariable_10 a2, 
                                   out seq_arr_uVariable_10 a3);
      seq_arr_uVariable_10_10
         dump_seq_arr_uVariable_10_10(in seq_arr_uVariable_10_10 a1, 
                                      inout seq_arr_uVariable_10_10 a2, 
                                      out seq_arr_uVariable_10_10 a3);
      seq_arr_uVariable_10_10_10
         dump_seq_arr_uVariable_10_10_10(in seq_arr_uVariable_10_10_10 a1, 
                                         inout seq_arr_uVariable_10_10_10 a2, 
                                         out seq_arr_uVariable_10_10_10 a3);

      seq_arrarr_uVariable 
         dump_seq_arrarr_uVariable(in seq_arrarr_uVariable a1, 
                                   inout seq_arrarr_uVariable a2, 
                                   out seq_arrarr_uVariable a3);
      seqseq_arrarr_uVariable 
         dump_seqseq_arrarr_uVariable(in seqseq_arrarr_uVariable a1, 
                                      inout seqseq_arrarr_uVariable a2, 
                                      out seqseq_arrarr_uVariable a3);
      seqseqseq_arrarr_uVariable 
         dump_seqseqseq_arrarr_uVariable(in seqseqseq_arrarr_uVariable a1, 
                                         inout seqseqseq_arrarr_uVariable a2, 
                                         out seqseqseq_arrarr_uVariable a3);

      seq_arrarr_uVariable_10 
         dump_seq_arrarr_uVariable_10(in seq_arrarr_uVariable_10 a1, 
                                      inout seq_arrarr_uVariable_10 a2, 
                                      out seq_arrarr_uVariable_10 a3);
      seq_arrarr_uVariable_10_10 
         dump_seq_arrarr_uVariable_10_10(in seq_arrarr_uVariable_10_10 a1, 
                                         inout seq_arrarr_uVariable_10_10 a2, 
                                         out seq_arrarr_uVariable_10_10 a3);
      seq_arrarr_uVariable_10_10_10 
         dump_seq_arrarr_uVariable_10_10_10(in seq_arrarr_uVariable_10_10_10 a1, 
                                            inout seq_arrarr_uVariable_10_10_10 a2, 
                                            out seq_arrarr_uVariable_10_10_10 a3);
   };


   interface Exercise {
      readonly attribute Exercise1 ex1;
      readonly attribute Exercise2 ex2;
      readonly attribute Exercise3 ex3;
      readonly attribute Exercise4 ex4;
      readonly attribute Exercise5 ex5;
      readonly attribute Exercise6 ex6;
      readonly attribute Exercise7 ex7;
      readonly attribute Exercise8 ex8;
      readonly attribute Exercise9 ex9;
      readonly attribute Exercise10 ex10;

      readonly attribute rf11 rf11Instance;
   };
};

#endif
