*** empty log message ***if_repo

13 files changed, 69481 insertions, 49730 deletions

diff --git a/TAO/tao/Interface.pidl b/TAO/tao/Interface.pidl
index e338817b36d..9d0765b7610 100644
--- a/TAO/tao/Interface.pidl
+++ b/TAO/tao/Interface.pidl
@@ -1,589 +1,1047 @@
 //$Id$
-#pragma prefix "omg.org"
 
-module CORBA {
-  typedef string Identifier;
-  typedef string ScopedName;
-  typedef string RepositoryId;
+#pragma prefix "omg.org"
+module IR 
+{
+  typedef CORBA::Identifier Identifier;
+  typedef CORBA::ScopedName ScopedName;
+  typedef CORBA::RepositoryId RepositoryId;
+
+  enum DefinitionKind 
+  {
+    dk_none, 
+    dk_all,
+    dk_Attribute, 
+    dk_Constant, 
+    dk_Exception, 
+    dk_Interface,
+    dk_Module, 
+    dk_Operation, 
+    dk_Typedef,
+    dk_Alias, 
+    dk_Struct, 
+    dk_Union, 
+    dk_Enum,
+    dk_Primitive, 
+    dk_String, 
+    dk_Sequence, 
+    dk_Array,
+    dk_Repository,
+    dk_Wstring, 
+    dk_Fixed,
+    dk_Value, 
+    dk_ValueBox, 
+    dk_ValueMember,
+    dk_Native,
+    dk_Component, 
+    dk_Home,
+    dk_Factory, 
+    dk_Finder, 
+    dk_PrimaryKey,
+    dk_Emits, 
+    dk_Publishes, 
+    dk_Consumes,
+    dk_Provides, 
+    dk_Uses
+  };
 
-enum DefinitionKind {
-	dk_none, dk_all,
-	dk_Attribute, dk_Constant, dk_Exception, dk_Interface,
-	dk_Module, dk_Operation, dk_Typedef,
-	dk_Alias, dk_Struct, dk_Union, dk_Enum,
-	dk_Primitive, dk_String, dk_Sequence, dk_Array,
-	dk_Repository,
-	dk_Wstring, dk_Fixed,
-        dk_Value, 
-        dk_ValueBox, dk_ValueMember, 
-        dk_Native
- };
-
-interface IRObject {
-	// read interface
-	readonly attribute DefinitionKind def_kind;
-	// write interface
-	void destroy ();
- };
-
-typedef string VersionSpec;
+  typedef string VersionSpec;
 
   interface Contained;
   interface Repository;
   interface Container;
 
- interface Contained : IRObject {
-	// read/write interface
-
-	attribute RepositoryId id;
-	attribute Identifier name;
-	attribute VersionSpec version;
-
-	// read interface
-
-	readonly attribute Container defined_in;
-	readonly attribute ScopedName absolute_name;
-	readonly attribute Repository containing_repository;
-
-	struct Description {
-	DefinitionKind kind;
-	any value; 
-	}; 
-
-	Description describe ();
-
-	// write interface
-
-	void move (
-		in Container new_container,
-		in Identifier new_name,
-		in VersionSpec new_version
-		   );
- 	 };
-
-	interface ModuleDef;
-  	interface ConstantDef;
-  	interface IDLType;
-  	interface StructDef;
-  	interface UnionDef;
-  	interface EnumDef;
-        interface AliasDef;
-  	interface InterfaceDef;
-        interface ExceptionDef; 
-        interface NativeDef;
-	typedef sequence <InterfaceDef> InterfaceDefSeq;
-        interface ValueDef; 
-        typedef sequence <ValueDef> ValueDefSeq; 
-        interface ValueBoxDef;
-
- 	typedef sequence <Contained> ContainedSeq;
-
-   		struct StructMember {
-		Identifier name;
-		TypeCode type;
-		IDLType type_def;
- 	 };
-
- 	 typedef sequence <StructMember> StructMemberSeq;
-        struct Initializer { 
-                StructMemberSeq members; 
-        }; 
-        typedef sequence <Initializer> InitializerSeq;
-
-		struct UnionMember {
-		Identifier name;
-		any label;
-		TypeCode type;
-		IDLType type_def;
-		};
-
- 	 typedef sequence <UnionMember> UnionMemberSeq;
-
- 	 typedef sequence <Identifier> EnumMemberSeq;
-
-	interface Container : IRObject {
-	// read interface
-
-	Contained lookup ( in ScopedName search_name);
-
-	ContainedSeq contents (
-		 in DefinitionKind limit_type,
-		 in boolean exclude_inherited
-	  );
-
-	ContainedSeq lookup_name (
-		in Identifier search_name, 
-		in long levels_to_search, 
-		in DefinitionKind limit_type,
-		in boolean exclude_inherited
-	 );
-
-	struct Description {
-	Contained contained_object; 
-	DefinitionKind kind;
-		any value; 
-	};
-
-	typedef sequence<Description> DescriptionSeq;
-
-	DescriptionSeq describe_contents (
-		in DefinitionKind limit_type,
-		in boolean exclude_inherited,
-		in long max_returned_objs
-	  );
-
-	// write interface
- 
-	ModuleDef create_module (
-		in RepositoryId id,
-		in Identifier name,
-		in VersionSpec version
-	 );
- 
-	ConstantDef create_constant (
-		in RepositoryId id,
-		in Identifier name,
-		in VersionSpec version,
-		in IDLType type,
-		in any value
-	 );
- 
-	StructDef create_struct (
-		in RepositoryId id,
-		in Identifier name,
-		in VersionSpec version,
-		in StructMemberSeq members
-	 );
- 
-	UnionDef create_union (
-		in RepositoryId id,
-		in Identifier name,
-		in VersionSpec version,
-		in IDLType discriminator_type,
-		in UnionMemberSeq members
-	 );
- 
-	EnumDef create_enum (
-		in RepositoryId id,
-		in Identifier name,
-		in VersionSpec version,
-		in EnumMemberSeq members
-	 );
- 
-	AliasDef create_alias (
-		in RepositoryId id,
-		in Identifier name,
-		in VersionSpec version,
-		in IDLType original_type
-	 );
- 
-	InterfaceDef create_interface (
-		in RepositoryId id,
-		in Identifier name,
-		in VersionSpec version,
-		in InterfaceDefSeq base_interfaces
-	   );
-
-        ValueDef create_value( 
-        in RepositoryId id, 
-        in Identifier name, 
-        in VersionSpec version, 
-        in boolean is_custom, 
-        in boolean is_abstract, 
-        in ValueDef base_value,        
-        in boolean is_truncatable, 
-        in ValueDefSeq abstract_base_values, 
-        in InterfaceDef supported_interface, 
-        in InitializerSeq initializers );
-
-        ValueBoxDef create_value_box( 
-        in RepositoryId id,
-        in Identifier name, 
-        in VersionSpec version, 
-        in IDLType original_type_def );
-
-	ExceptionDef create_exception(
-		in RepositoryId id,
-		in Identifier name,
-		in VersionSpec version,
-		in StructMemberSeq members
-	);
- };
-
-
-   interface IDLType : IRObject {
-	readonly attribute TypeCode type;
+  interface Contained : CORBA::IRObject 
+  {
+    // read/write interface
+    attribute RepositoryId id;
+    attribute Identifier name;
+    attribute VersionSpec version;
+
+    // read interface
+    readonly attribute Container defined_in;
+    readonly attribute ScopedName absolute_name;
+    readonly attribute Repository containing_repository;
+
+    struct Description 
+    {
+      DefinitionKind kind;
+      any value;
+    };
+
+    Description describe ();
+
+    // write interface
+    void move (
+        in Container new_container,
+        in Identifier new_name,
+        in VersionSpec new_version
+      );
+  };
+
+  interface ModuleDef;
+  interface ConstantDef;
+  interface IDLType;
+  interface StructDef;
+  interface UnionDef;
+  interface EnumDef;
+  interface AliasDef;
+  interface InterfaceDef;
+  interface ExceptionDef;
+  interface NativeDef;
+  typedef sequence <InterfaceDef> InterfaceDefSeq;
+  interface ValueDef;
+  typedef sequence <ValueDef> ValueDefSeq;
+  interface ValueBoxDef;
+  interface ComponentDef;
+  typedef sequence <ComponentDef> ComponentDefSeq;
+  interface ProvidesDef;
+  typedef sequence <ProvidesDef> ProvidesDefSeq;
+  interface UsesDef;
+  typedef sequence <UsesDef> UsesDefSeq;
+  interface HomeDef;
+  typedef sequence <HomeDef> HomeDefSeq;
+  interface EventDef;
+  interface EmitsDef;
+  typedef sequence <EmitsDef> EmitsDefSeq;
+  interface PublishesDef;
+  typedef sequence <PublishesDef> PublishesDefSeq;
+  interface ConsumesDef;
+  typedef sequence <ConsumesDef> ConsumesDefSeq;
+  interface FactoryDef;
+  typedef sequence <FactoryDef> FactoryDefSeq;
+  interface FinderDef;
+  typedef sequence <FinderDef> FinderDefSeq;
+  interface PrimaryKeyDef;
+  typedef sequence <Contained> ContainedSeq;
+
+  struct StructMember 
+  {
+    Identifier name;
+    CORBA::TypeCode type;
+    IDLType type_def;
+  };
+
+  typedef sequence <StructMember> StructMemberSeq;
+
+  struct Initializer 
+  {
+    StructMemberSeq members;
+    Identifier name;
+  };
+
+  typedef sequence <Initializer> InitializerSeq;
+
+  struct UnionMember 
+  {
+    Identifier name;
+    any label;
+    CORBA:: TypeCode type;
+    IDLType type_def;
+  };
+
+  typedef sequence <UnionMember> UnionMemberSeq;
+  typedef sequence <Identifier> EnumMemberSeq;
+
+  interface Container : CORBA::IRObject 
+  {
+    // read interface
+    Contained lookup (
+        in ScopedName search_name
+      );
+    ContainedSeq contents (
+        in DefinitionKind limit_type,
+        in boolean exclude_inherited
+      );
+    ContainedSeq lookup_name (
+        in Identifier search_name,
+        in long levels_to_search,
+        in DefinitionKind limit_type,
+        in boolean exclude_inherited
+      );
+    struct Description 
+    {
+      Contained contained_object;
+      DefinitionKind kind;
+      any value;
+    };
+
+    typedef sequence<Description> DescriptionSeq;
+
+    DescriptionSeq describe_contents (
+        in DefinitionKind limit_type,
+        in boolean exclude_inherited,
+        in long max_returned_objs
+      );
+    // write interface
+    ModuleDef create_module (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version
+      );
+    ConstantDef create_constant (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType type,
+        in any value
+      );
+    StructDef create_struct (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in StructMemberSeq members
+      );
+    UnionDef create_union (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType discriminator_type,
+        in UnionMemberSeq members
+      );
+    EnumDef create_enum (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in EnumMemberSeq members
+      );
+    AliasDef create_alias (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType original_type
+      );
+    InterfaceDef create_interface (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in InterfaceDefSeq base_interfaces,
+        in boolean is_abstract
+      );
+    ValueDef create_value (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in boolean is_custom,
+        in boolean is_abstract,
+        in ValueDef base_value,
+        in boolean is_truncatable,
+        in ValueDefSeq abstract_base_values,
+        in InterfaceDefSeq supported_interfaces,
+        in InitializerSeq initializers
+      );
+    ValueBoxDef create_value_box (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType original_type_def
+      );
+    ExceptionDef create_exception (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in StructMemberSeq members
+      );
+    NativeDef create_native (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version
+      );
   };
 
+  interface IDLType : CORBA::IRObject 
+  {
+    readonly attribute CORBA::TypeCode type;
+  };
 
   interface PrimitiveDef;
   interface StringDef;
   interface SequenceDef;
   interface ArrayDef;
-  interface WstringDef; 
+  interface WstringDef;
   interface FixedDef;
 
-   enum PrimitiveKind {
-	pk_null, pk_void, pk_short, pk_long, pk_ushort, pk_ulong,
-	pk_float, pk_double, pk_boolean, pk_char, pk_octet,
-	pk_any, pk_TypeCode, pk_Principal, pk_string, pk_objref,
-	pk_longlong, pk_ulonglong, pk_longdouble, pk_wchar, pk_wstring
-   };
+  enum PrimitiveKind 
+  {
+    pk_null, 
+    pk_void, 
+    pk_short, 
+    pk_long, 
+    pk_ushort, 
+    pk_ulong,
+    pk_float, 
+    pk_double, 
+    pk_boolean, 
+    pk_char, 
+    pk_octet,
+    pk_any, 
+    pk_TypeCode, 
+    pk_Principal, 
+    pk_string, 
+    pk_objref,
+    pk_longlong, 
+    pk_ulonglong, 
+    pk_longdouble,
+    pk_wchar, 
+    pk_wstring, 
+    pk_value_base
+  };
 
- interface Repository : Container {
-	// read interface
+  interface Repository : Container 
+  {
+    // read interface
+    Contained lookup_id (
+        in RepositoryId search_id
+      );
+    CORBA::TypeCode get_canonical_typecode (
+        in CORBA::TypeCode tc
+      );
+    PrimitiveDef get_primitive (
+        in PrimitiveKind kind
+      );
+    // write interface
+    StringDef create_string (
+        in unsigned long bound
+      );
+    WstringDef create_wstring (
+        in unsigned long bound
+      );
+    SequenceDef create_sequence (
+        in unsigned long bound,
+        in IDLType element_type
+      );
+    ArrayDef create_array (
+        in unsigned long length,
+        in IDLType element_type
+      );
+    FixedDef create_fixed (
+        in unsigned short digits,
+        in short scale
+      );
+  };
 
-	Contained lookup_id (in RepositoryId search_id);
+  interface ComponentRepository : Repository
+  {
+    ComponentDef create_component (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in ComponentDef base_component,
+        in InterfaceDefSeq supports_interfaces
+      );
+    HomeDef create_home (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in HomeDef base_home,
+        in ComponentDef managed_component,
+        in ValueDef primary_key
+      );
+  };
 
-	PrimitiveDef get_primitive (in PrimitiveKind kind);
+  interface ModuleDef : Container, Contained 
+  {
+  };
 
-	// write interface
+  struct ModuleDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+  };
 
-	StringDef create_string (in unsigned long bound);
+  interface ConstantDef : Contained 
+  {
+    readonly attribute CORBA::TypeCode type;
+    attribute IDLType type_def;
+    attribute any value;
+  };
 
-	WstringDef create_wstring (in unsigned long bound);
+  struct ConstantDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::TypeCode type;
+    any value;
+  };
 
-	SequenceDef create_sequence (
-		in unsigned long bound,
-	 	in IDLType element_type
-	  );
+  interface TypedefDef : Contained, IDLType 
+  {
+  };
 
-	ArrayDef create_array (
-		in unsigned long length,
-		in IDLType element_type
-	 );
-        
-	FixedDef create_fixed (
-		in unsigned short digits,
-		 in short scale
-	  );
-   };
+  struct TypeDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::TypeCode type;
+  };
 
-  interface ModuleDef : Container, Contained {
-   };
+  interface StructDef : TypedefDef, Container 
+  {
+    attribute StructMemberSeq members;
+  };
 
-   struct ModuleDescription {
-	Identifier name; 
-	RepositoryId id; 
-	RepositoryId defined_in;
-	VersionSpec version;
+  interface UnionDef : TypedefDef, Container 
+  {
+    readonly attribute CORBA::TypeCode discriminator_type;
+    attribute IDLType discriminator_type_def;
+    attribute UnionMemberSeq members;
   };
 
+  interface EnumDef : TypedefDef 
+  {
+    attribute EnumMemberSeq members;
+  };
 
-  interface ConstantDef : Contained {
-	readonly attribute TypeCode type;
-	attribute IDLType type_def;
-	attribute any value;
-   };
+  interface AliasDef : TypedefDef 
+  {
+    attribute IDLType original_type_def;
+  };
 
- struct ConstantDescription {
-	Identifier name; 
-	RepositoryId id; 
-	RepositoryId defined_in; 
-	VersionSpec version;
-	TypeCode type; 
-	any value; 
-    };
+  interface NativeDef : TypedefDef 
+  {
+  };
 
+  interface PrimitiveDef: IDLType 
+  {
+    readonly attribute PrimitiveKind kind;
+  };
 
-  	interface TypedefDef : Contained, IDLType {
-   };
+  interface StringDef : IDLType 
+  {
+    attribute unsigned long bound;
+  };
 
-   struct TypeDescription {
-	Identifier name; 
-	RepositoryId id; 
-	RepositoryId defined_in; 
-	VersionSpec version;
-	TypeCode type; 
-   };
+  interface WstringDef : IDLType 
+  {
+    attribute unsigned long bound;
+  };
 
+  interface FixedDef : IDLType 
+  {
+    attribute unsigned short digits;
+    attribute short scale;
+  };
 
-    interface StructDef : TypedefDef, Container {
-	attribute StructMemberSeq members;
-	};
+  interface SequenceDef : IDLType 
+  {
+    attribute unsigned long bound;
+    readonly attribute CORBA::TypeCode element_type;
+    attribute IDLType element_type_def;
+  };
 
+  interface ArrayDef : IDLType 
+  {
+    attribute unsigned long length;
+    readonly attribute CORBA::TypeCode element_type;
+    attribute IDLType element_type_def;
+  };
 
+  interface ExceptionDef : Contained, Container 
+  {
+    readonly attribute CORBA::TypeCode type;
+    attribute StructMemberSeq members;
+  };
 
- interface UnionDef : TypedefDef, Container {
-	readonly attribute TypeCode discriminator_type;
-	attribute IDLType discriminator_type_def;
-	attribute UnionMemberSeq members;
-    };
+  struct ExceptionDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::TypeCode type;
+  };
 
+  typedef sequence <ExceptionDef> ExceptionDefSeq;
+  typedef sequence <ExceptionDescription> ExcDescriptionSeq;
 
-  interface EnumDef : TypedefDef {
-	attribute EnumMemberSeq members;
+  enum AttributeMode 
+  {
+    ATTR_NORMAL, 
+    ATTR_READONLY
   };
 
+  interface AttributeDef : Contained 
+  {
+    readonly attribute CORBA::TypeCode type;
+    attribute IDLType type_def;
+    attribute AttributeMode mode;
+  };
 
-   interface AliasDef : TypedefDef {
-	attribute IDLType original_type_def;
+  struct AttributeDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::TypeCode type;
+    AttributeMode mode;
+    ExcDescriptionSeq get_exceptions;
+    ExcDescriptionSeq put_exceptions;
   };
 
+  enum OperationMode 
+  {
+    OP_NORMAL, 
+    OP_ONEWAY
+  };
 
- interface PrimitiveDef: IDLType {
-	readonly attribute PrimitiveKind kind;
- };
+  enum ParameterMode 
+  {
+    PARAM_IN, 
+    PARAM_OUT, 
+    PARAM_INOUT
+  };
 
+  struct ParameterDescription 
+  {
+    Identifier name;
+    CORBA::TypeCode type;
+    IDLType type_def;
+    ParameterMode mode;
+  };
 
- interface StringDef : IDLType {
-	attribute unsigned long bound;
+  typedef sequence <ParameterDescription> ParDescriptionSeq;
+  typedef Identifier ContextIdentifier;
+  typedef sequence <ContextIdentifier> ContextIdSeq;
+
+  interface OperationDef : Contained 
+  {
+    readonly attribute CORBA::TypeCode result;
+    attribute IDLType result_def;
+    attribute ParDescriptionSeq params;
+    attribute OperationMode mode;
+    attribute ContextIdSeq contexts;
+    attribute ExceptionDefSeq exceptions;
   };
 
-interface WstringDef : IDLType {
-	attribute unsigned long bound;
- };
+  struct OperationDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::TypeCode result;
+    OperationMode mode;
+    ContextIdSeq contexts;
+    ParDescriptionSeq parameters;
+    ExcDescriptionSeq exceptions;
+  };
 
- interface FixedDef : IDLType {
-	attribute unsigned short digits;
-	attribute short scale;
- };
+  typedef sequence <RepositoryId> RepositoryIdSeq;
+  typedef sequence <OperationDescription> OpDescriptionSeq;
+  typedef sequence <AttributeDescription> AttrDescriptionSeq;
+
+  interface InterfaceDef : Container, Contained, IDLType 
+  {
+    // read/write interface
+    attribute InterfaceDefSeq base_interfaces;
+    // read interface
+    attribute boolean is_abstract;
+    attribute boolean is_local;
+    boolean is_a (
+        in RepositoryId interface_id
+      );
+    // write interface
+    AttributeDef create_attribute (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType type,
+        in AttributeMode mode,
+        in ExceptionDefSeq get_exceptions,
+        in ExceptionDefSeq put_exceptions
+      );
+    OperationDef create_operation (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType result,
+        in OperationMode mode,
+        in ParDescriptionSeq params,
+        in ExceptionDefSeq exceptions,
+        in ContextIdSeq contexts
+      );
+  };
 
- interface SequenceDef : IDLType {
-	attribute unsigned long bound;
-	readonly attribute TypeCode element_type;
-	attribute IDLType element_type_def;
+  struct InterfaceDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    OpDescriptionSeq operations;
+    AttrDescriptionSeq attributes;
+    RepositoryIdSeq base_interfaces;
+    CORBA::TypeCode type;
+    boolean is_abstract;
+    boolean is_local;
   };
 
+  struct ValueMember 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    CORBA::TypeCode type;
+    IDLType type_def;
+    CORBA::Visibility access;
+  };
+
+  typedef sequence <ValueMember> ValueMemberSeq;
+
+  interface ValueMemberDef : Contained 
+  {
+    readonly attribute CORBA::TypeCode type;
+    attribute IDLType type_def;
+    attribute CORBA::Visibility access;
+  };
+
+  interface ValueDef : Container, Contained, IDLType 
+  {
+    // read/write interface
+    attribute InterfaceDefSeq supported_interfaces;
+    attribute InitializerSeq initializers;
+    attribute ValueDef base_value;
+    attribute ValueDefSeq abstract_base_values;
+    // read interface
+    attribute boolean is_abstract;
+    attribute boolean is_custom;
+    attribute boolean is_truncatable;
+    boolean is_a (
+        in RepositoryId id
+      );
+    ValueMemberDef create_value_member (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType type,
+        in CORBA::Visibility access
+      );
+    AttributeDef create_attribute (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType type,
+        in AttributeMode mode,
+        in ExceptionDefSeq get_exceptions,
+        in ExceptionDefSeq put_exceptions
+      );
+    OperationDef create_operation (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in IDLType result,
+        in OperationMode mode,
+        in ParDescriptionSeq params,
+        in ExceptionDefSeq exceptions,
+        in ContextIdSeq contexts
+      );
+  };
+
+  struct ValueDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    boolean is_abstract;
+    boolean is_custom;
+    RepositoryId defined_in;
+    VersionSpec version;
+    OpDescriptionSeq operations;
+    AttrDescriptionSeq attributes;
+    ValueMemberSeq members;
+    InitializerSeq initializers;
+    RepositoryIdSeq supported_interfaces;
+    RepositoryIdSeq abstract_base_values;
+    boolean is_truncatable;
+    RepositoryId base_value;
+    CORBA::TypeCode type;
+  };
+
+  interface ValueBoxDef : TypedefDef 
+  {
+    attribute IDLType original_type_def;
+  };
+
+  interface ProvidesDef : Contained 
+  {
+    // read interface
+    readonly attribute InterfaceDef interface_type;
+  };
+
+  struct ProvidesDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    InterfaceDef interface_type;
+  };
 
- interface ArrayDef : IDLType {
-	attribute unsigned long length;
-	readonly attribute TypeCode element_type;
-	attribute IDLType element_type_def;
- };
+  interface UsesDef : Contained 
+  {
+    // read interface
+    readonly attribute InterfaceDef interface_type;
+    readonly attribute boolean is_multiple;
+  };
 
+  struct UsesDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    InterfaceDef interface_type;
+    boolean is_multiple;
+  };
 
-  interface ExceptionDef : Contained, Container {
-	readonly attribute TypeCode type;
-	attribute StructMemberSeq members;
- };
+  typedef sequence <ProvidesDescription> ProvidesDescSeq;
+  typedef sequence <UsesDescription> UsesDescSeq;
 
-struct ExceptionDescription {
-Identifier name; 
-	RepositoryId id; 
-	RepositoryId defined_in; 
-	VersionSpec version;
-	TypeCode type; 
-  	};
-enum AttributeMode {ATTR_NORMAL, ATTR_READONLY};
+  interface EventDef : Contained 
+  { // abstract - never instantiated
+    // read interface
+    boolean is_a (in RepositoryId event_id);
+    readonly attribute ValueDef event;
+  };
 
-  	interface AttributeDef : Contained {
-	readonly attribute TypeCode type;
-	attribute IDLType type_def;
-	attribute AttributeMode mode;
-   };
+  struct EventDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    ValueDef value;
+  };
 
-   	struct AttributeDescription {
-	Identifier name; 
-	RepositoryId id; 
-	RepositoryId defined_in; 
-	VersionSpec version;
-	TypeCode type;
-	AttributeMode mode; 
-   };
+  interface EmitsDef : EventDef 
+  {
+  };
 
+  interface PublishesDef : EventDef 
+  {
+  };
 
-  enum OperationMode {OP_NORMAL, OP_ONEWAY};
+  interface ConsumesDef : EventDef 
+  {
+  };
 
-  enum ParameterMode {PARAM_IN, PARAM_OUT, PARAM_INOUT};
-   	struct ParameterDescription {
-	Identifier name; 
-	TypeCode type; 
-	IDLType type_def;
-	ParameterMode mode;
- };
- typedef sequence <ParameterDescription> ParDescriptionSeq;
-
- typedef Identifier ContextIdentifier;
- typedef sequence <ContextIdentifier> ContextIdSeq;
-
- typedef sequence <ExceptionDef> ExceptionDefSeq;
- typedef sequence <ExceptionDescription> ExcDescriptionSeq;
-
- interface OperationDef : Contained { 
-	readonly attribute TypeCode result;
-	attribute IDLType result_def;
-	attribute ParDescriptionSeq params;
-	attribute OperationMode mode; 
-	attribute ContextIdSeq contexts;
-	attribute ExceptionDefSeq exceptions;
-  };
-
- struct OperationDescription {
-	Identifier name; 
-	RepositoryId id; 
-	RepositoryId defined_in; 
-	VersionSpec version;
-	TypeCode result; 
-	OperationMode mode; 
-	ContextIdSeq contexts; 
-	ParDescriptionSeq parameters;
-	ExcDescriptionSeq exceptions;
- 	};
-
-
- typedef sequence <RepositoryId> RepositoryIdSeq;
- typedef sequence <OperationDescription> OpDescriptionSeq;
- typedef sequence <AttributeDescription> AttrDescriptionSeq;
-
-interface InterfaceDef : Container, Contained, IDLType {
-	// read/write interface
-
-	attribute InterfaceDefSeq base_interfaces;
-
-	// read interface
-
-	boolean is_a (in RepositoryId interface_id);
-
-	struct FullInterfaceDescription {
-	 	Identifier name;
-	 	RepositoryId id;
-	 	RepositoryId defined_in;
-	  	VersionSpec version;
-	   	OpDescriptionSeq operations;
-	   	AttrDescriptionSeq attributes;
-	   	RepositoryIdSeq base_interfaces;
-	  	TypeCode type;
-                boolean is_abstract;
-	};
-
-	FullInterfaceDescription describe_interface();
-
-	// write interface
-
-	AttributeDef create_attribute (
-	   	 in RepositoryId id,
-		 in Identifier name,
-	 	 in VersionSpec version,
-	 	 in IDLType type,
-	 	 in AttributeMode mode
-	 	 );
-
-	OperationDef create_operation (
-	    	in RepositoryId id,
-	   	in Identifier name,
-	   	in VersionSpec version,
-	   	in IDLType result,
-	   	in OperationMode mode, 
-	   	in ParDescriptionSeq params,
-	    	in ExceptionDefSeq exceptions,
-	   	in ContextIdSeq contexts
-	   );
-   };
-
- 	struct InterfaceDescription {
-		Identifier name; 
-		RepositoryId id; 
-		RepositoryId defined_in; 
-		VersionSpec version;
-		RepositoryIdSeq base_interfaces;
-                boolean is_abstract;    
-	};
-
-
-        typedef short Visibility; 
-        const Visibility PRIVATE_MEMBER = 0; 
-        const Visibility PUBLIC_MEMBER = 1; 
-        
-        struct ValueMember { 
-        Identifier name; 
-        RepositoryId id; 
-        RepositoryId defined_in; 
-        VersionSpec version; 
-        TypeCode type; 
-        IDLType type_def; 
-        Visibility access; }; 
-        
-        typedef sequence <ValueMember> ValueMemberSeq; 
-        interface ValueMemberDef : Contained { 
-        readonly attribute TypeCode type; 
-        attribute IDLType type_def; 
-        attribute Visibility access; }; 
-
-        interface ValueDef : Container, Contained, IDLType { 
-        
-        // read/write interface 
-        attribute InterfaceDef supported_interface; 
-        attribute InitializerSeq initializers;
-
-        attribute ValueDef base_value; 
-        attribute ValueDefSeq abstract_base_values; 
-        attribute boolean is_abstract; 
-        attribute boolean is_custom; 
-        attribute boolean is_truncatable; 
-
-        // read interface 
-        boolean is_a( in RepositoryId value_id );
-	
-        struct FullValueDescription { 
-        Identifier name; 
-        RepositoryId id; 
-        boolean is_abstract; 
-        boolean is_custom; 
-        RepositoryId defined_in; 
-        VersionSpec version; 
-        OpDescriptionSeq operations; 
-        AttrDescriptionSeq attributes; 
-        ValueMemberSeq members; 
-        InitializerSeq initializers; 
-        RepositoryIdSeq supported_interfaces; 
-        RepositoryIdSeq abstract_base_values; 
-        boolean is_truncatable; 
-        RepositoryId base_value; 
-        TypeCode type; };
-
-        FullValueDescription describe_value(); 
-        
-        ValueMemberDef create_value_member( 
-        in RepositoryId id, 
-        in Identifier name, 
-        in VersionSpec version, 
-        in IDLType type, 
-        in Visibility access ); 
-        
-        AttributeDef create_attribute( 
-        in RepositoryId id, 
-        in Identifier name, 
-        in VersionSpec version, 
-        in IDLType type, 
-        in AttributeMode mode );
-
-        OperationDef create_operation ( 
-        in RepositoryId id, 
-        in Identifier name, 
+  interface ComponentDef : InterfaceDef 
+  {
+    // read/write interface
+    attribute InterfaceDefSeq supported_interfaces;
+    // read interface
+    readonly attribute ComponentDef base_component;
+    readonly attribute ProvidesDefSeq provides_interfaces;
+    readonly attribute UsesDefSeq uses_interfaces;
+    readonly attribute EmitsDefSeq emits_events;
+    readonly attribute PublishesDefSeq publishes_events;
+    readonly attribute ConsumesDefSeq consumes_events;
+    readonly attribute boolean is_basic;
+    // write interface
+    ProvidesDef create_provides (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in InterfaceDef interface_type
+      );
+    UsesDef create_uses (
+        in RepositoryId id,
+        in Identifier name,
         in VersionSpec version,
+        in InterfaceDef interface_type,
+        in boolean is_multiple
+      );
+    EmitsDef create_emits (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in ValueDef value
+      );
+    PublishesDef create_publishes (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in ValueDef value
+      );
+    ConsumesDef create_consumes (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in ValueDef value
+      );
+  };
+
+  struct ComponentDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    RepositoryId base_component;
+    RepositoryIdSeq supports_interfaces;
+    ProvidesDefSeq provides_interfaces;
+    UsesDefSeq uses_interfaces;
+    AttrDescriptionSeq attributes;
+    EmitsDefSeq emits_events;
+    PublishesDefSeq publishes_events;
+    ConsumesDefSeq consumes_events;
+    boolean is_basic;
+  };
+
+  interface PrimaryKeyDef : Contained 
+  {
+    // read interface
+    boolean is_a (in RepositoryId primary_key_id);
+    readonly attribute ValueDef primary_key;
+  };
+
+  struct PrimaryKeyDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    ValueDef primary_key;
+  };
+
+  interface FactoryDef : OperationDef 
+  { // only PARAM_IN parameters
+  };
+
+  interface FinderDef : OperationDef 
+  { // only PARAM_IN parameters
+  };
+
+  interface HomeDef : InterfaceDef 
+  {
+    // read operations
+    readonly attribute HomeDef base_home;
+    readonly attribute ComponentDef managed_component;
+    readonly attribute PrimaryKeyDef primary_key;
+    readonly attribute FactoryDefSeq factories;
+    readonly attribute FinderDefSeq finders;
+    readonly attribute boolean is_basic;
+    // write interfaces
+    PrimaryKeyDef create_primary_key (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in ValueDef primary_key
+      );
+    FactoryDef create_factory (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in ParDescriptionSeq params, // only PARAM_INs
+        in ExceptionDefSeq exceptions
+      );
+    FinderDef create_finder (
+        in RepositoryId id,
+        in Identifier name,
+        in VersionSpec version,
+        in ParDescriptionSeq params, // only PARAM_INs
+        in ExceptionDefSeq exceptions
+      );
+  };
+
+  struct HomeDescription 
+  {
+    Identifier name;
+    RepositoryId id;
+    RepositoryId defined_in;
+    VersionSpec version;
+    RepositoryId base_home;
+    RepositoryId managed_component;
+    PrimaryKeyDef primary_key_def;
+    FactoryDefSeq factories;
+    FinderDefSeq finders;
+    OpDescriptionSeq operations;
+    AttrDescriptionSeq attributes;
+    boolean is_basic;
+  };
+};
+
+module CORBA 
+{
+  typedef string Identifier;
+  typedef string ScopedName;
+  typedef string RepositoryId;
+
+  interface IRObject 
+  {
+    // read interface
+    readonly attribute DefinitionKind def_kind;
+    // write interface
+    void destroy ();
+  };
+
+// This just gets put in corbafwd.h.
+#if 0
+  enum TCKind 
+  { // PIDL
+    tk_null, tk_void,
+    tk_short, tk_long, tk_ushort, tk_ulong,
+    tk_float, tk_double, tk_boolean, tk_char,
+    tk_octet, tk_any, tk_TypeCode, tk_Principal, tk_objref,
+    tk_struct, tk_union, tk_enum, tk_string,
+    tk_sequence, tk_array, tk_alias, tk_except,
+    tk_longlong, tk_ulonglong, tk_longdouble,
+    tk_wchar, tk_wstring, tk_fixed,
+    tk_value, tk_value_box,
+    tk_native,
+    tk_abstract_interface,
+    tk_component, tk_home
+  };
+#endif /* 0 */
+
+  typedef short ValueModifier; // PIDL
+  const ValueModifier VM_NONE = 0;
+  const ValueModifier VM_CUSTOM = 1;
+  const ValueModifier VM_ABSTRACT = 2;
+  const ValueModifier VM_TRUNCATABLE = 3;
+  typedef short Visibility;
+  const Visibility PRIVATE_MEMBER = 0;
+  const Visibility PUBLIC_MEMBER = 1;
+
+// Not generated.
+#if 0
+  interface TypeCode 
+  { // PIDL
+    exception Bounds {};
+    exception BadKind {};
+    // for all TypeCode kinds
+    boolean equal (in TypeCode tc);
+    boolean equivalent(in TypeCode tc);
+    TypeCode get_compact_typecode();
+    TCKind kind ();
+    // for tk_objref, tk_struct, tk_union, tk_enum, tk_alias,
+    // tk_value, tk_value_box, tk_native, tk_abstract_interface,
+    // tk_except, tk_component, tk_home
+    RepositoryId id () raises (BadKind);
+    // for tk_objref, tk_struct, tk_union, tk_enum, tk_alias,
+    // tk_value, tk_value_box, tk_native, tk_abstract_interface
+    // tk_except, tk_component, tk_home
+    Identifier name () raises (BadKind);
+    // for tk_struct, tk_union, tk_enum, tk_value,
+    // and tk_except
+    unsigned long member_count () raises (BadKind);
+    Identifier member_name (in unsigned long index)
+      raises (BadKind, Bounds);
+    // for tk_struct, tk_union, tk_value, and tk_except
+    TypeCode member_type (in unsigned long index)
+      raises (BadKind, Bounds);
+    // for tk_union
+    any member_label (in unsigned long index)
+      raises (BadKind, Bounds);
+    TypeCode discriminator_type () raises (BadKind);
+    long default_index () raises (BadKind);
+    // for tk_string, tk_sequence, and tk_array
+    unsigned long length () raises (BadKind);
+    // for tk_sequence, tk_array, tk_value_box, and tk_alias
+    TypeCode content_type () raises (BadKind);
+    // for tk_fixed
+    unsigned short fixed_digits() raises (BadKind);
+    short fixed_scale() raises (BadKind);
+    // for tk_value
+    Visibility member_visibility(in unsigned long index)
+      raises(BadKind, Bounds);
+    ValueModifier type_modifier() raises(BadKind);
+    TypeCode concrete_base_type() raises(BadKind);
+  };
+#endif /* 0 */
+
+  // The TypeCode related part of interface ORB moved to
+  // the TypeCodeFactory interface.
+  // A reference to this interface can be obtained from
+  // resolve_initial_references with argument "TypeCodeFactory".
+  interface TypeCodeFactory 
+  { // PIDL
+    TypeCode create_struct_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in StructMemberSeq members
+      );
+    TypeCode create_union_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in TypeCode discriminator_type,
+        in UnionMemberSeq members
+      );
+    TypeCode create_enum_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in EnumMemberSeq members
+      );
+    TypeCode create_alias_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in TypeCode original_type
+      );
+    TypeCode create_exception_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in StructMemberSeq members
+      );
+    TypeCode create_interface_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+    TypeCode create_string_tc (
+        in unsigned long bound
+      );
+    TypeCode create_wstring_tc (
+        in unsigned long bound
+      );
+    TypeCode create_fixed_tc (
+        in unsigned short digits,
+        in unsigned short scale
+      );
+    TypeCode create_sequence_tc (
+        in unsigned long bound,
+        in TypeCode element_type
+      );
+    TypeCode create_array_tc (
+        in unsigned long length,
+        in TypeCode element_type
+      );
+    TypeCode create_value_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in ValueModifier type_modifier,
+        in TypeCode concrete_base,
+        in ValueMemberSeq members
+      );
+    TypeCode create_value_box_tc (
+        in RepositoryId id,
+        in Identifier name,
+        in TypeCode boxed_type
+      );
+    TypeCode create_native_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+    TypeCode create_recursive_tc (
+        in RepositoryId id
+      );
+    TypeCode create_abstract_interface_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+    TypeCode create_component_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+    TypeCode create_home_tc (
+        in RepositoryId id,
+        in Identifier name
+      );
+  };
+};
 
-        in IDLType result, 
-        in OperationMode mode, 
-        in ParDescriptionSeq params, 
-        in ExceptionDefSeq exceptions, 
-        in ContextIdSeq contexts ); 
-        
-        };
-
-       struct ValueDescription 
-       { 
-         Identifier name; 
-         RepositoryId id; 
-         boolean is_abstract; 
-         boolean is_custom; 
-         RepositoryId defined_in; 
-         VersionSpec version; 
-         RepositoryId supported_interface; 
-         RepositoryIdSeq abstract_base_values; 
-         boolean is_truncatable; 
-         RepositoryId base_value; 
-       }; 
-
-       interface ValueBoxDef : IDLType 
-       { attribute IDLType original_type_def; };
-
-       
-
-       typedef short ValueModifier; 
-       const ValueModifier VM_NONE = 0; 
-       const ValueModifier VM_CUSTOM = 1; 
-       const ValueModifier VM_ABSTRACT = 2; 
-       const ValueModifier VM_TRUNCATABLE = 3;
-
-        };
diff --git a/TAO/tao/InterfaceC.cpp b/TAO/tao/InterfaceC.cpp
index ed812703572..8d6921f5a9b 100644
--- a/TAO/tao/InterfaceC.cpp
+++ b/TAO/tao/InterfaceC.cpp
@@ -1,5 +1,4 @@
-/* -*- C++ -*- */
-//$Id$
+/* -*- C++ -*- $Id$ */
 
 // ******  Code generated by the The ACE ORB (TAO) IDL Compiler *******
 // TAO and the TAO IDL Compiler have been developed by the Center for
@@ -8,56 +7,79 @@
 // Information about TAO is available at:
 //                 http://www.cs.wustl.edu/~schmidt/TAO.html
 
-#include "tao/InterfaceC.h"
+#include "InterfaceC.h"
 #include "tao/Stub.h"
 #include "tao/Invocation.h"
 
 #if (TAO_HAS_INTERFACE_REPOSITORY == 1)
 
 #if !defined (__ACE_INLINE__)
-#include "tao/InterfaceC.i"
+#include "InterfaceC.i"
 #endif /* !defined INLINE */
 
-static const CORBA::Long _oc_CORBA_Identifier[] =
+static const CORBA::Long _oc_IR_Identifier[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
   11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-  CORBA::tk_string,
-  0U, // string length
-};
-static CORBA::TypeCode _tc_TAO_tc_CORBA_Identifier (CORBA::tk_alias, sizeof (_oc_CORBA_Identifier), (char *) &_oc_CORBA_Identifier, 0, sizeof (CORBA::Identifier));
-
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_string, 
+    0U, // string length
 
-static const CORBA::Long _oc_CORBA_ScopedName[] =
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_Identifier (CORBA::tk_alias, sizeof (_oc_IR_Identifier), (char *) &_oc_IR_Identifier, 0, sizeof (IR::Identifier));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Identifier, &_tc_TAO_tc_IR_Identifier)
+TAO_NAMESPACE_END
+static const CORBA::Long _oc_IR_ScopedName[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5363), ACE_NTOHL (0x6f706564), ACE_NTOHL (0x4e616d65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ScopedName:1.0
+  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x636f7065), ACE_NTOHL (0x644e616d), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ScopedName:1.0
   11, ACE_NTOHL (0x53636f70), ACE_NTOHL (0x65644e61), ACE_NTOHL (0x6d650000),  // name = ScopedName
-  CORBA::tk_string,
-  0U, // string length
+  CORBA::tk_alias, // typecode kind for typedefs
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5363), ACE_NTOHL (0x6f706564), ACE_NTOHL (0x4e616d65), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ScopedName:1.0
+    11, ACE_NTOHL (0x53636f70), ACE_NTOHL (0x65644e61), ACE_NTOHL (0x6d650000),  // name = ScopedName
+    CORBA::tk_string, 
+    0U, // string length
+
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ScopedName (CORBA::tk_alias, sizeof (_oc_CORBA_ScopedName), (char *) &_oc_CORBA_ScopedName, 0, sizeof (CORBA::ScopedName));
+static CORBA::TypeCode _tc_TAO_tc_IR_ScopedName (CORBA::tk_alias, sizeof (_oc_IR_ScopedName), (char *) &_oc_IR_ScopedName, 0, sizeof (IR::ScopedName));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ScopedName, &_tc_TAO_tc_CORBA_ScopedName)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ScopedName, &_tc_TAO_tc_IR_ScopedName)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_RepositoryId[] =
+static const CORBA::Long _oc_IR_RepositoryId[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
   13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-  CORBA::tk_string,
-  0U, // string length
-};
-static CORBA::TypeCode _tc_TAO_tc_CORBA_RepositoryId (CORBA::tk_alias, sizeof (_oc_CORBA_RepositoryId), (char *) &_oc_CORBA_RepositoryId, 0, sizeof (CORBA::RepositoryId));
+  CORBA::tk_alias, // typecode kind for typedefs
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_string, 
+    0U, // string length
 
-static const CORBA::Long _oc_CORBA_DefinitionKind[] =
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_RepositoryId (CORBA::tk_alias, sizeof (_oc_IR_RepositoryId), (char *) &_oc_IR_RepositoryId, 0, sizeof (IR::RepositoryId));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryId, &_tc_TAO_tc_IR_RepositoryId)
+TAO_NAMESPACE_END
+static const CORBA::Long _oc_IR_DefinitionKind[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4465), ACE_NTOHL (0x66696e69), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4b696e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/DefinitionKind:1.0
+  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f44), ACE_NTOHL (0x6566696e), ACE_NTOHL (0x6974696f), ACE_NTOHL (0x6e4b696e), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/DefinitionKind:1.0
   15, ACE_NTOHL (0x44656669), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x6f6e4b69), ACE_NTOHL (0x6e640000),  // name = DefinitionKind
-  24, // member count
+  34, // member count
   8, ACE_NTOHL (0x646b5f6e), ACE_NTOHL (0x6f6e6500),  // name = dk_none
   7, ACE_NTOHL (0x646b5f61), ACE_NTOHL (0x6c6c0000),  // name = dk_all
   13, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x0),  // name = dk_Attribute
@@ -82,134 +104,203 @@ static const CORBA::Long _oc_CORBA_DefinitionKind[] =
   12, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
   15, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65720000),  // name = dk_ValueMember
   10, ACE_NTOHL (0x646b5f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65000000),  // name = dk_Native
+  13, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x0),  // name = dk_Component
+  8, ACE_NTOHL (0x646b5f48), ACE_NTOHL (0x6f6d6500),  // name = dk_Home
+  11, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72790000),  // name = dk_Factory
+  10, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72000000),  // name = dk_Finder
+  14, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79000000),  // name = dk_PrimaryKey
+  9, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x0),  // name = dk_Emits
+  13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x0),  // name = dk_Publishes
+  12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657300),  // name = dk_Consumes
+  12, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657300),  // name = dk_Provides
+  8, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x73657300),  // name = dk_Uses
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_DefinitionKind (CORBA::tk_enum, sizeof (_oc_CORBA_DefinitionKind), (char *) &_oc_CORBA_DefinitionKind, 0, sizeof (CORBA::DefinitionKind));
+static CORBA::TypeCode _tc_TAO_tc_IR_DefinitionKind (CORBA::tk_enum, sizeof (_oc_IR_DefinitionKind), (char *) &_oc_IR_DefinitionKind, 0, sizeof (IR::DefinitionKind));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_DefinitionKind, &_tc_TAO_tc_CORBA_DefinitionKind)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_DefinitionKind, &_tc_TAO_tc_IR_DefinitionKind)
 TAO_NAMESPACE_END
-CORBA_IRObject_ptr CORBA_IRObject::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void CORBA::IRObject::_tao_any_destructor (void *x)
+{
+  IRObject *tmp = ACE_static_cast (IRObject*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::IRObject_ptr CORBA::IRObject::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_IRObject::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/IRObject:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_IRObject::_nil ());
+    return IRObject::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:CORBA/IRObject:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (IRObject::_nil ());
   if (is_a == 0)
-    return CORBA_IRObject::_nil ();
-  return CORBA_IRObject::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return IRObject::_nil ();
+  return IRObject::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_IRObject_ptr CORBA_IRObject::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+CORBA::IRObject_ptr CORBA::IRObject::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_IRObject::_nil ();
+    return IRObject::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
+  if (stub)
+    stub->_incr_refcnt ();
+  IRObject_ptr default_proxy = IRObject::_nil ();
   if (obj->_is_collocated () && _TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer != 0)
     {
-      CORBA_IRObject_ptr retv = _TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_IRObject_ptr retval = CORBA_IRObject::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_IRObject (stub),
-                  CORBA_IRObject::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, IRObject (stub), IRObject::_nil ());
+  return TAO_CORBA_IRObject_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_IRObject_ptr
-CORBA_IRObject::_duplicate (CORBA_IRObject_ptr obj)
+CORBA::IRObject_ptr 
+CORBA::IRObject::_duplicate (IRObject_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::DefinitionKind CORBA_IRObject::def_kind (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::DefinitionKind CORBA::IRObject::def_kind (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
- CORBA::DefinitionKind _tao_retval = (CORBA::DefinitionKind)0;
-
-
+  
+  CORBA::DefinitionKind _tao_retval = (CORBA::DefinitionKind)0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""def_kind",
+      "_get_def_kind",
       13,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_def_kind",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_def_kind",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_def_kind",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_IRObject::destroy (
-    CORBA_Environment &ACE_TRY_ENV
+void CORBA::IRObject::destroy (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "destroy",
@@ -217,52 +308,243 @@ void CORBA_IRObject::destroy (
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "destroy",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "destroy",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "destroy",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_IRObject::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean CORBA::IRObject::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
   else
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_IRObject::_interface_repository_id (void) const
+const char* CORBA::IRObject::_interface_repository_id (void) const
+{
+  return "IDL:CORBA/IRObject:1.0";
+}
+
+CORBA::TAO_CORBA_IRObject_Default_Proxy_Factory::TAO_CORBA_IRObject_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_CORBA_IRObject_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+CORBA::TAO_CORBA_IRObject_Default_Proxy_Factory::~TAO_CORBA_IRObject_Default_Proxy_Factory (void)
+{
+}
+
+CORBA::IRObject_ptr
+CORBA::TAO_CORBA_IRObject_Default_Proxy_Factory::create_proxy (
+    ::CORBA::IRObject_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+CORBA::TAO_CORBA_IRObject_Proxy_Factory_Adapter::TAO_CORBA_IRObject_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+CORBA::TAO_CORBA_IRObject_Proxy_Factory_Adapter::~TAO_CORBA_IRObject_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+CORBA::TAO_CORBA_IRObject_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_CORBA_IRObject_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+CORBA::TAO_CORBA_IRObject_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+CORBA::IRObject_ptr
+CORBA::TAO_CORBA_IRObject_Proxy_Factory_Adapter::create_proxy (
+    ::CORBA::IRObject_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_CORBA_IRObject_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+CORBA::TAO_CORBA_IRObject_Smart_Proxy_Base::TAO_CORBA_IRObject_Smart_Proxy_Base (::CORBA::IRObject_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+CORBA::TAO_CORBA_IRObject_Smart_Proxy_Base::~TAO_CORBA_IRObject_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+CORBA::TAO_CORBA_IRObject_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::DefinitionKind CORBA::TAO_CORBA_IRObject_Smart_Proxy_Base::def_kind  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  return "IDL:omg.org/CORBA/IRObject:1.0";
+  return this->base_proxy_->def_kind (
+      ACE_TRY_ENV
+    );
+
 }
 
+void CORBA::TAO_CORBA_IRObject_Smart_Proxy_Base::destroy  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->destroy (
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<CORBA::TAO_CORBA_IRObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<CORBA::TAO_CORBA_IRObject_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
 static const CORBA::Long _oc_CORBA_IRObject[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
@@ -274,616 +556,1135 @@ TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
 TAO_NAMESPACE_BEGIN (CORBA)
 TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IRObject, &_tc_TAO_tc_CORBA_IRObject)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_VersionSpec[] =
+static const CORBA::Long _oc_IR_VersionSpec[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
   12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-  CORBA::tk_string,
+  CORBA::tk_string, 
   0U, // string length
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_VersionSpec (CORBA::tk_alias, sizeof (_oc_CORBA_VersionSpec), (char *) &_oc_CORBA_VersionSpec, 0, sizeof (CORBA::VersionSpec));
+static CORBA::TypeCode _tc_TAO_tc_IR_VersionSpec (CORBA::tk_alias, sizeof (_oc_IR_VersionSpec), (char *) &_oc_IR_VersionSpec, 0, sizeof (IR::VersionSpec));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_VersionSpec, &_tc_TAO_tc_CORBA_VersionSpec)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_VersionSpec, &_tc_TAO_tc_IR_VersionSpec)
 TAO_NAMESPACE_END
-CORBA_Contained_ptr CORBA_Contained::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::Contained::_tao_any_destructor (void *x)
+{
+  Contained *tmp = ACE_static_cast (Contained*,x);
+  CORBA::release (tmp);
+}
+
+IR::Contained_ptr IR::Contained::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_Contained::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Contained:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_Contained::_nil ());
+    return Contained::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/Contained:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (Contained::_nil ());
   if (is_a == 0)
-    return CORBA_Contained::_nil ();
-  return CORBA_Contained::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return Contained::_nil ();
+  return Contained::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_Contained_ptr CORBA_Contained::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::Contained_ptr IR::Contained::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_Contained::_nil ();
+    return Contained::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_Contained_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  Contained_ptr default_proxy = Contained::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_Contained_Stub_Factory_function_pointer != 0)
     {
-      CORBA_Contained_ptr retv = _TAO_collocation_CORBA_Contained_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_Contained_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_Contained_ptr retval = CORBA_Contained::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_Contained (stub),
-                  CORBA_Contained::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, Contained (stub), Contained::_nil ());
+  return TAO_IR_Contained_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_Contained_ptr
-CORBA_Contained::_duplicate (CORBA_Contained_ptr obj)
+IR::Contained_ptr 
+IR::Contained::_duplicate (Contained_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-char * CORBA_Contained::id (
-    CORBA_Environment &ACE_TRY_ENV
+char * IR::Contained::id (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  char* _tao_retval = 0;
-
-
+  
+  CORBA::String_var _tao_safe_retval;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""id",
+      "_get_id",
       7,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_id",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_id",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_id",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_Contained::id (
+void IR::Contained::id (
     const char * id,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""id",
+      "_set_id",
       7,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_id",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_id",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_id",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-char * CORBA_Contained::name (
-    CORBA_Environment &ACE_TRY_ENV
+char * IR::Contained::name (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  char* _tao_retval = 0;
-
-
+  
+  CORBA::String_var _tao_safe_retval;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""name",
+      "_get_name",
       9,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_name",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_name",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_name",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_Contained::name (
+void IR::Contained::name (
     const char * name,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""name",
+      "_set_name",
       9,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << name)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_name",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << name)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_name",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_name",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-char * CORBA_Contained::version (
-    CORBA_Environment &ACE_TRY_ENV
+char * IR::Contained::version (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  char* _tao_retval = 0;
-
-
+  
+  CORBA::String_var _tao_safe_retval;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""version",
+      "_get_version",
       12,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_version",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_version",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_version",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_Contained::version (
+void IR::Contained::version (
     const char * version,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""version",
+      "_set_version",
       12,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << version)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_version",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << version)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_version",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_version",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA_Container_ptr CORBA_Contained::defined_in (
-    CORBA_Environment &ACE_TRY_ENV
+IR::Container_ptr IR::Contained::defined_in (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_Container_ptr _tao_retval = CORBA_Container::_nil ();
-
-
+  
+  IR::Container_ptr _tao_retval = IR::Container::_nil ();
+  IR::Container_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""defined_in",
+      "_get_defined_in",
       15,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_defined_in",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_defined_in",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_defined_in",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-char * CORBA_Contained::absolute_name (
-    CORBA_Environment &ACE_TRY_ENV
+char * IR::Contained::absolute_name (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  char* _tao_retval = 0;
-
-
+  
+  CORBA::String_var _tao_safe_retval;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""absolute_name",
+      "_get_absolute_name",
       18,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_absolute_name",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_absolute_name",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_absolute_name",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_Repository_ptr CORBA_Contained::containing_repository (
-    CORBA_Environment &ACE_TRY_ENV
+IR::Repository_ptr IR::Contained::containing_repository (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_Repository_ptr _tao_retval = CORBA_Repository::_nil ();
-
-
+  
+  IR::Repository_ptr _tao_retval = IR::Repository::_nil ();
+  IR::Repository_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""containing_repository",
+      "_get_containing_repository",
       26,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_containing_repository",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_containing_repository",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_containing_repository",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-static const CORBA::Long _oc_CORBA_Contained_Description[] =
+static const CORBA::Long _oc_IR_Contained_Description[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  44, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e65642f), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained/Description:1.0
+  41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x2f446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained/Description:1.0
   12, ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = Description
   2, // member count
   5, ACE_NTOHL (0x6b696e64), ACE_NTOHL (0x0),  // name = kind
   CORBA::tk_enum, // typecode kind
-  472, // encapsulation length
+  632, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4465), ACE_NTOHL (0x66696e69), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4b696e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/DefinitionKind:1.0
+    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f44), ACE_NTOHL (0x6566696e), ACE_NTOHL (0x6974696f), ACE_NTOHL (0x6e4b696e), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/DefinitionKind:1.0
     15, ACE_NTOHL (0x44656669), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x6f6e4b69), ACE_NTOHL (0x6e640000),  // name = DefinitionKind
-    24, // member count
+    34, // member count
     8, ACE_NTOHL (0x646b5f6e), ACE_NTOHL (0x6f6e6500),  // name = dk_none
     7, ACE_NTOHL (0x646b5f61), ACE_NTOHL (0x6c6c0000),  // name = dk_all
     13, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x0),  // name = dk_Attribute
@@ -908,30 +1709,47 @@ static const CORBA::Long _oc_CORBA_Contained_Description[] =
     12, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
     15, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65720000),  // name = dk_ValueMember
     10, ACE_NTOHL (0x646b5f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65000000),  // name = dk_Native
+    13, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x0),  // name = dk_Component
+    8, ACE_NTOHL (0x646b5f48), ACE_NTOHL (0x6f6d6500),  // name = dk_Home
+    11, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72790000),  // name = dk_Factory
+    10, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72000000),  // name = dk_Finder
+    14, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79000000),  // name = dk_PrimaryKey
+    9, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x0),  // name = dk_Emits
+    13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x0),  // name = dk_Publishes
+    12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657300),  // name = dk_Consumes
+    12, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657300),  // name = dk_Provides
+    8, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x73657300),  // name = dk_Uses
 
   6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
   CORBA::tk_any,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_Contained_Description (CORBA::tk_struct, sizeof (_oc_CORBA_Contained_Description), (char *) &_oc_CORBA_Contained_Description, 0, sizeof (CORBA_Contained::Description));
-CORBA::TypeCode_ptr CORBA_Contained::_tc_Description = &_tc_TAO_tc_CORBA_Contained_Description;
+static CORBA::TypeCode _tc_TAO_tc_IR_Contained_Description (CORBA::tk_struct, sizeof (_oc_IR_Contained_Description), (char *) &_oc_IR_Contained_Description, 0, sizeof (IR::Contained::Description));
+CORBA::TypeCode_ptr IR::Contained::_tc_Description = &_tc_TAO_tc_IR_Contained_Description;
+
+void IR::Contained::Description::_tao_any_destructor (void *x)
+{
+  Description *tmp = ACE_static_cast (Description*,x);
+  delete tmp;
+}
 
-CORBA_Contained::Description * CORBA_Contained::describe (
-    CORBA_Environment &ACE_TRY_ENV
+IR::Contained::Description * IR::Contained::describe (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_Contained::Description* _tao_retval = 0;
-
+  
+  IR::Contained::Description *_tao_retval = 0;
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_Contained::Description, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::Contained::Description, _tao_retval);
+  IR::Contained::Description_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "describe",
@@ -939,61 +1757,119 @@ CORBA_Contained::Description * CORBA_Contained::describe (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "describe",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "describe",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "describe",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_Contained::move (
-    CORBA_Container_ptr new_container,
+void IR::Contained::move (
+    IR::Container_ptr new_container,
     const char * new_name,
     const char * new_version,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "move",
@@ -1001,49 +1877,105 @@ void CORBA_Contained::move (
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << new_container) &&
-          (_tao_out << new_name) &&
-          (_tao_out << new_version)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "move",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << new_container) &&
+              (_tao_out << new_name) &&
+              (_tao_out << new_version)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "move",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "move",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_Contained::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::Contained::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -1051,445 +1983,2091 @@ CORBA::Boolean CORBA_Contained::_is_a (const CORBA::Char *value, CORBA_Environme
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_Contained::_interface_repository_id (void) const
+const char* IR::Contained::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/Contained:1.0";
+}
+
+IR::TAO_IR_Contained_Default_Proxy_Factory::TAO_IR_Contained_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_Contained_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_Contained_Default_Proxy_Factory::~TAO_IR_Contained_Default_Proxy_Factory (void)
+{
+}
+
+IR::Contained_ptr
+IR::TAO_IR_Contained_Default_Proxy_Factory::create_proxy (
+    ::IR::Contained_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_Contained_Proxy_Factory_Adapter::TAO_IR_Contained_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_Contained_Proxy_Factory_Adapter::~TAO_IR_Contained_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_Contained_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_Contained_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_Contained_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::Contained_ptr
+IR::TAO_IR_Contained_Proxy_Factory_Adapter::create_proxy (
+    ::IR::Contained_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_Contained_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_Contained_Smart_Proxy_Base::TAO_IR_Contained_Smart_Proxy_Base (::IR::Contained_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_Contained_Smart_Proxy_Base::~TAO_IR_Contained_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_Contained_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+char * IR::TAO_IR_Contained_Smart_Proxy_Base::id  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->id (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_Contained_Smart_Proxy_Base::id  (
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->id (
+      id,
+      ACE_TRY_ENV
+    );
+
+}
+
+char * IR::TAO_IR_Contained_Smart_Proxy_Base::name  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->name (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_Contained_Smart_Proxy_Base::name  (
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->name (
+      name,
+      ACE_TRY_ENV
+    );
+
+}
+
+char * IR::TAO_IR_Contained_Smart_Proxy_Base::version  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->version (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_Contained_Smart_Proxy_Base::version  (
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->version (
+      version,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::Container_ptr IR::TAO_IR_Contained_Smart_Proxy_Base::defined_in  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->defined_in (
+      ACE_TRY_ENV
+    );
+
+}
+
+char * IR::TAO_IR_Contained_Smart_Proxy_Base::absolute_name  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->absolute_name (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::Repository_ptr IR::TAO_IR_Contained_Smart_Proxy_Base::containing_repository  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  return "IDL:omg.org/CORBA/Contained:1.0";
+  return this->base_proxy_->containing_repository (
+      ACE_TRY_ENV
+    );
+
 }
 
-static const CORBA::Long _oc_CORBA_Contained[] =
+IR::Contained::Description * IR::TAO_IR_Contained_Smart_Proxy_Base::describe  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->describe (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_Contained_Smart_Proxy_Base::move  (
+    IR::Container_ptr new_container,
+    const char * new_name,
+    const char * new_version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->move (
+      new_container,
+      new_name,
+      new_version,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_Contained_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_Contained_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_Contained[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e65643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained:1.0
+  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained:1.0
   10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64000000),  // name = Contained
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_Contained (CORBA::tk_objref, sizeof (_oc_CORBA_Contained), (char *) &_oc_CORBA_Contained, 0, sizeof (CORBA_Contained));
+static CORBA::TypeCode _tc_TAO_tc_IR_Contained (CORBA::tk_objref, sizeof (_oc_IR_Contained), (char *) &_oc_IR_Contained, 0, sizeof (IR::Contained));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Contained, &_tc_TAO_tc_CORBA_Contained)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Contained, &_tc_TAO_tc_IR_Contained)
 TAO_NAMESPACE_END
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CS_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CS_
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_INTERFACEDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_INTERFACEDEFSEQ_CS_
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_InterfaceDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (length);
-
+    IR::InterfaceDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_InterfaceDef **old = ACE_reinterpret_cast (CORBA_InterfaceDef**, this->buffer_);
+      IR::InterfaceDef **old = ACE_reinterpret_cast (IR::InterfaceDef**, this->buffer_);
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         if (!this->release_)
-          tmp[i] = CORBA_InterfaceDef::_duplicate (old[i]);
+          tmp[i] = IR::InterfaceDef::_duplicate (old[i]);
         else
           tmp[i] = old[i];
-
+        
       if (this->release_)
         delete[] old;
-
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-    CORBA_InterfaceDef **tmp = ACE_reinterpret_cast (CORBA_InterfaceDef**, this->buffer_);
+    IR::InterfaceDef **tmp = ACE_reinterpret_cast (IR::InterfaceDef**, this->buffer_);
     for (CORBA::ULong i = 0; i < this->length_; ++i)
     {
       CORBA::release (tmp[i]);
-      tmp[i] = CORBA_InterfaceDef::_nil ();
+      tmp[i] = IR::InterfaceDef::_nil ();
     }
-    _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (tmp);
+    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::freebuf (tmp);
     this->buffer_ = 0;
   }
-
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::~_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (void)
   {
     this->_deallocate_buffer ();
   }
-
+  
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
   {
-    CORBA_InterfaceDef **tmp = ACE_reinterpret_cast (CORBA_InterfaceDef**, this->buffer_);
-
+    IR::InterfaceDef **tmp = ACE_reinterpret_cast (IR::InterfaceDef**, this->buffer_);
+    
     for (CORBA::ULong i = nl; i < ol; ++i)
     {
       CORBA::release (tmp[i]);
-      tmp[i] = CORBA_InterfaceDef::_nil ();
+      tmp[i] = IR::InterfaceDef::_nil ();
     }
   }
-  void
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_downcast (
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_downcast (
       void* target,
       CORBA_Object *src,
       CORBA_Environment &ACE_TRY_ENV
     )
   {
-    CORBA_InterfaceDef **tmp = ACE_static_cast (CORBA_InterfaceDef**, target);
-    *tmp = CORBA_InterfaceDef::_narrow (src, ACE_TRY_ENV);
+    IR::InterfaceDef **tmp = ACE_static_cast (IR::InterfaceDef**, target);
+    *tmp = IR::InterfaceDef::_narrow (src, ACE_TRY_ENV);
   }
 
   CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_upcast (void *src) const
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_upcast (void *src) const
   {
-    CORBA_InterfaceDef **tmp = ACE_static_cast (CORBA_InterfaceDef**, src);
+    IR::InterfaceDef **tmp = ACE_static_cast (IR::InterfaceDef**, src);
     return *tmp;
   }
-
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_INTERFACEDEFSEQ_CS_)
-#define _CORBA_INTERFACEDEFSEQ_CS_
+#if !defined (_IR_INTERFACEDEFSEQ_CS_)
+#define _IR_INTERFACEDEFSEQ_CS_
 
 // *************************************************************
-// CORBA_InterfaceDefSeq
+// IR::InterfaceDefSeq
 // *************************************************************
 
-CORBA_InterfaceDefSeq::CORBA_InterfaceDefSeq (void)
+IR::InterfaceDefSeq::InterfaceDefSeq (void)
 {}
-CORBA_InterfaceDefSeq::CORBA_InterfaceDefSeq (CORBA::ULong max) // uses max size
-  :
+IR::InterfaceDefSeq::InterfaceDefSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq
+  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_InterfaceDef,CORBA_InterfaceDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::InterfaceDef,IR::InterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_InterfaceDefSeq::CORBA_InterfaceDefSeq (CORBA::ULong max, CORBA::ULong length, CORBA_InterfaceDef_ptr *buffer, CORBA::Boolean release)
-  :
+IR::InterfaceDefSeq::InterfaceDefSeq (CORBA::ULong max, CORBA::ULong length, IR::InterfaceDef_ptr *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq
+  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_InterfaceDef,CORBA_InterfaceDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::InterfaceDef,IR::InterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_InterfaceDefSeq::CORBA_InterfaceDefSeq (const CORBA_InterfaceDefSeq &seq) // copy ctor
-  :
+IR::InterfaceDefSeq::InterfaceDefSeq (const InterfaceDefSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq
+  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_InterfaceDef,CORBA_InterfaceDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::InterfaceDef,IR::InterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_InterfaceDefSeq::~CORBA_InterfaceDefSeq (void) // dtor
+IR::InterfaceDefSeq::~InterfaceDefSeq (void) // dtor
 {}
+void IR::InterfaceDefSeq::_tao_any_destructor (void *x)
+{
+  InterfaceDefSeq *tmp = ACE_static_cast (InterfaceDefSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_InterfaceDefSeq[] =
+static const CORBA::Long _oc_IR_InterfaceDefSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x74657266), ACE_NTOHL (0x61636544), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/InterfaceDefSeq:1.0
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/InterfaceDefSeq:1.0
   16, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x53657100),  // name = InterfaceDefSeq
   CORBA::tk_sequence, // typecode kind
-  80, // encapsulation length
+  76, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_objref, // typecode kind
-    64, // encapsulation length
+    60, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x74657266), ACE_NTOHL (0x61636544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef:1.0
+      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
       13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = InterfaceDef
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_InterfaceDefSeq (CORBA::tk_alias, sizeof (_oc_CORBA_InterfaceDefSeq), (char *) &_oc_CORBA_InterfaceDefSeq, 0, sizeof (CORBA_InterfaceDefSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_InterfaceDefSeq (CORBA::tk_alias, sizeof (_oc_IR_InterfaceDefSeq), (char *) &_oc_IR_InterfaceDefSeq, 0, sizeof (IR::InterfaceDefSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDefSeq, &_tc_TAO_tc_CORBA_InterfaceDefSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDefSeq, &_tc_TAO_tc_IR_InterfaceDefSeq)
 TAO_NAMESPACE_END
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CS_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CS_
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_VALUEDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_VALUEDEFSEQ_CS_
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_ValueDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (length);
-
+    IR::ValueDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_ValueDef **old = ACE_reinterpret_cast (CORBA_ValueDef**, this->buffer_);
+      IR::ValueDef **old = ACE_reinterpret_cast (IR::ValueDef**, this->buffer_);
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         if (!this->release_)
-          tmp[i] = CORBA_ValueDef::_duplicate (old[i]);
+          tmp[i] = IR::ValueDef::_duplicate (old[i]);
         else
           tmp[i] = old[i];
-
+        
       if (this->release_)
         delete[] old;
-
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-    CORBA_ValueDef **tmp = ACE_reinterpret_cast (CORBA_ValueDef**, this->buffer_);
+    IR::ValueDef **tmp = ACE_reinterpret_cast (IR::ValueDef**, this->buffer_);
     for (CORBA::ULong i = 0; i < this->length_; ++i)
     {
       CORBA::release (tmp[i]);
-      tmp[i] = CORBA_ValueDef::_nil ();
+      tmp[i] = IR::ValueDef::_nil ();
     }
-    _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (tmp);
+    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::freebuf (tmp);
     this->buffer_ = 0;
   }
-
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (void)
   {
     this->_deallocate_buffer ();
   }
-
+  
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
   {
-    CORBA_ValueDef **tmp = ACE_reinterpret_cast (CORBA_ValueDef**, this->buffer_);
-
+    IR::ValueDef **tmp = ACE_reinterpret_cast (IR::ValueDef**, this->buffer_);
+    
     for (CORBA::ULong i = nl; i < ol; ++i)
     {
       CORBA::release (tmp[i]);
-      tmp[i] = CORBA_ValueDef::_nil ();
+      tmp[i] = IR::ValueDef::_nil ();
     }
   }
-  void
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_downcast (
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_downcast (
       void* target,
       CORBA_Object *src,
       CORBA_Environment &ACE_TRY_ENV
     )
   {
-    CORBA_ValueDef **tmp = ACE_static_cast (CORBA_ValueDef**, target);
-    *tmp = CORBA_ValueDef::_narrow (src, ACE_TRY_ENV);
+    IR::ValueDef **tmp = ACE_static_cast (IR::ValueDef**, target);
+    *tmp = IR::ValueDef::_narrow (src, ACE_TRY_ENV);
   }
 
   CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_upcast (void *src) const
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_upcast (void *src) const
   {
-    CORBA_ValueDef **tmp = ACE_static_cast (CORBA_ValueDef**, src);
+    IR::ValueDef **tmp = ACE_static_cast (IR::ValueDef**, src);
     return *tmp;
   }
-
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_VALUEDEFSEQ_CS_)
-#define _CORBA_VALUEDEFSEQ_CS_
+#if !defined (_IR_VALUEDEFSEQ_CS_)
+#define _IR_VALUEDEFSEQ_CS_
 
 // *************************************************************
-// CORBA_ValueDefSeq
+// IR::ValueDefSeq
 // *************************************************************
 
-CORBA_ValueDefSeq::CORBA_ValueDefSeq (void)
+IR::ValueDefSeq::ValueDefSeq (void)
 {}
-CORBA_ValueDefSeq::CORBA_ValueDefSeq (CORBA::ULong max) // uses max size
-  :
+IR::ValueDefSeq::ValueDefSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq
+  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_ValueDef,CORBA_ValueDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ValueDef,IR::ValueDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_ValueDefSeq::CORBA_ValueDefSeq (CORBA::ULong max, CORBA::ULong length, CORBA_ValueDef_ptr *buffer, CORBA::Boolean release)
-  :
+IR::ValueDefSeq::ValueDefSeq (CORBA::ULong max, CORBA::ULong length, IR::ValueDef_ptr *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq
+  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_ValueDef,CORBA_ValueDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ValueDef,IR::ValueDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_ValueDefSeq::CORBA_ValueDefSeq (const CORBA_ValueDefSeq &seq) // copy ctor
-  :
+IR::ValueDefSeq::ValueDefSeq (const ValueDefSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq
+  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_ValueDef,CORBA_ValueDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ValueDef,IR::ValueDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_ValueDefSeq::~CORBA_ValueDefSeq (void) // dtor
+IR::ValueDefSeq::~ValueDefSeq (void) // dtor
 {}
+void IR::ValueDefSeq::_tao_any_destructor (void *x)
+{
+  ValueDefSeq *tmp = ACE_static_cast (ValueDefSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_ValueDefSeq[] =
+static const CORBA::Long _oc_IR_ValueDefSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c756544), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueDefSeq:1.0
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueDefSeq:1.0
   12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x53657100),  // name = ValueDefSeq
   CORBA::tk_sequence, // typecode kind
-  72, // encapsulation length
+  68, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_objref, // typecode kind
-    56, // encapsulation length
+    52, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c756544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ValueDef:1.0
+      28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDef:1.0
       9, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = ValueDef
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueDefSeq (CORBA::tk_alias, sizeof (_oc_CORBA_ValueDefSeq), (char *) &_oc_CORBA_ValueDefSeq, 0, sizeof (CORBA_ValueDefSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_ValueDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ValueDefSeq), (char *) &_oc_IR_ValueDefSeq, 0, sizeof (IR::ValueDefSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDefSeq, &_tc_TAO_tc_CORBA_ValueDefSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDefSeq, &_tc_TAO_tc_IR_ValueDefSeq)
 TAO_NAMESPACE_END
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CS_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CS_
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CS_
 
   // The Base_Sequence functions, please see tao/Sequence.h
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_Contained **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (length);
+    IR::ComponentDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::ComponentDef **old = ACE_reinterpret_cast (IR::ComponentDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::ComponentDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::ComponentDef **tmp = ACE_reinterpret_cast (IR::ComponentDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ComponentDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::ComponentDef **tmp = ACE_reinterpret_cast (IR::ComponentDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ComponentDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::ComponentDef **tmp = ACE_static_cast (IR::ComponentDef**, target);
+    *tmp = IR::ComponentDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_upcast (void *src) const
+  {
+    IR::ComponentDef **tmp = ACE_static_cast (IR::ComponentDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_COMPONENTDEFSEQ_CS_)
+#define _IR_COMPONENTDEFSEQ_CS_
+
+// *************************************************************
+// IR::ComponentDefSeq
+// *************************************************************
+
+IR::ComponentDefSeq::ComponentDefSeq (void)
+{}
+IR::ComponentDefSeq::ComponentDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ComponentDef,IR::ComponentDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ComponentDefSeq::ComponentDefSeq (CORBA::ULong max, CORBA::ULong length, IR::ComponentDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ComponentDef,IR::ComponentDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ComponentDefSeq::ComponentDefSeq (const ComponentDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ComponentDef,IR::ComponentDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ComponentDefSeq::~ComponentDefSeq (void) // dtor
+{}
+void IR::ComponentDefSeq::_tao_any_destructor (void *x)
+{
+  ComponentDefSeq *tmp = ACE_static_cast (ComponentDefSeq*,x);
+  delete tmp;
+}
 
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ComponentDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ComponentDefSeq:1.0
+  16, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74446566), ACE_NTOHL (0x53657100),  // name = ComponentDefSeq
+  CORBA::tk_sequence, // typecode kind
+  76, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    60, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ComponentDef:1.0
+      13, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74446566), ACE_NTOHL (0x0),  // name = ComponentDef
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ComponentDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ComponentDefSeq), (char *) &_oc_IR_ComponentDefSeq, 0, sizeof (IR::ComponentDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentDefSeq, &_tc_TAO_tc_IR_ComponentDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::ProvidesDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_Contained **old = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);
+      IR::ProvidesDef **old = ACE_reinterpret_cast (IR::ProvidesDef**, this->buffer_);
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         if (!this->release_)
-          tmp[i] = CORBA_Contained::_duplicate (old[i]);
+          tmp[i] = IR::ProvidesDef::_duplicate (old[i]);
         else
           tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::ProvidesDef **tmp = ACE_reinterpret_cast (IR::ProvidesDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ProvidesDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::ProvidesDef **tmp = ACE_reinterpret_cast (IR::ProvidesDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ProvidesDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::ProvidesDef **tmp = ACE_static_cast (IR::ProvidesDef**, target);
+    *tmp = IR::ProvidesDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_upcast (void *src) const
+  {
+    IR::ProvidesDef **tmp = ACE_static_cast (IR::ProvidesDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDEFSEQ_CS_)
+#define _IR_PROVIDESDEFSEQ_CS_
 
+// *************************************************************
+// IR::ProvidesDefSeq
+// *************************************************************
+
+IR::ProvidesDefSeq::ProvidesDefSeq (void)
+{}
+IR::ProvidesDefSeq::ProvidesDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ProvidesDef,IR::ProvidesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ProvidesDefSeq::ProvidesDefSeq (CORBA::ULong max, CORBA::ULong length, IR::ProvidesDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ProvidesDef,IR::ProvidesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ProvidesDefSeq::ProvidesDefSeq (const ProvidesDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ProvidesDef,IR::ProvidesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ProvidesDefSeq::~ProvidesDefSeq (void) // dtor
+{}
+void IR::ProvidesDefSeq::_tao_any_destructor (void *x)
+{
+  ProvidesDefSeq *tmp = ACE_static_cast (ProvidesDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ProvidesDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ProvidesDefSeq:1.0
+  15, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = ProvidesDefSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDef:1.0
+      12, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656600),  // name = ProvidesDef
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ProvidesDefSeq), (char *) &_oc_IR_ProvidesDefSeq, 0, sizeof (IR::ProvidesDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDefSeq, &_tc_TAO_tc_IR_ProvidesDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::UsesDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::UsesDef **old = ACE_reinterpret_cast (IR::UsesDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::UsesDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
       if (this->release_)
         delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::UsesDef **tmp = ACE_reinterpret_cast (IR::UsesDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::UsesDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::UsesDef **tmp = ACE_reinterpret_cast (IR::UsesDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::UsesDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::UsesDef **tmp = ACE_static_cast (IR::UsesDef**, target);
+    *tmp = IR::UsesDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_upcast (void *src) const
+  {
+    IR::UsesDef **tmp = ACE_static_cast (IR::UsesDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_USESDEFSEQ_CS_)
+#define _IR_USESDEFSEQ_CS_
+
+// *************************************************************
+// IR::UsesDefSeq
+// *************************************************************
 
+IR::UsesDefSeq::UsesDefSeq (void)
+{}
+IR::UsesDefSeq::UsesDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::UsesDef,IR::UsesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::UsesDefSeq::UsesDefSeq (CORBA::ULong max, CORBA::ULong length, IR::UsesDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::UsesDef,IR::UsesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::UsesDefSeq::UsesDefSeq (const UsesDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::UsesDef,IR::UsesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::UsesDefSeq::~UsesDefSeq (void) // dtor
+{}
+void IR::UsesDefSeq::_tao_any_destructor (void *x)
+{
+  UsesDefSeq *tmp = ACE_static_cast (UsesDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_UsesDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/UsesDefSeq:1.0
+  11, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = UsesDefSeq
+  CORBA::tk_sequence, // typecode kind
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    48, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDef:1.0
+      8, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656600),  // name = UsesDef
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_UsesDefSeq (CORBA::tk_alias, sizeof (_oc_IR_UsesDefSeq), (char *) &_oc_IR_UsesDefSeq, 0, sizeof (IR::UsesDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDefSeq, &_tc_TAO_tc_IR_UsesDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::HomeDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::HomeDef **old = ACE_reinterpret_cast (IR::HomeDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::HomeDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
     }
     this->buffer_ = tmp;
   }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::HomeDef **tmp = ACE_reinterpret_cast (IR::HomeDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::HomeDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::~_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::HomeDef **tmp = ACE_reinterpret_cast (IR::HomeDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::HomeDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::HomeDef **tmp = ACE_static_cast (IR::HomeDef**, target);
+    *tmp = IR::HomeDef::_narrow (src, ACE_TRY_ENV);
+  }
 
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_upcast (void *src) const
+  {
+    IR::HomeDef **tmp = ACE_static_cast (IR::HomeDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_HOMEDEFSEQ_CS_)
+#define _IR_HOMEDEFSEQ_CS_
+
+// *************************************************************
+// IR::HomeDefSeq
+// *************************************************************
+
+IR::HomeDefSeq::HomeDefSeq (void)
+{}
+IR::HomeDefSeq::HomeDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::HomeDef,IR::HomeDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::HomeDefSeq::HomeDefSeq (CORBA::ULong max, CORBA::ULong length, IR::HomeDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::HomeDef,IR::HomeDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::HomeDefSeq::HomeDefSeq (const HomeDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::HomeDef,IR::HomeDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::HomeDefSeq::~HomeDefSeq (void) // dtor
+{}
+void IR::HomeDefSeq::_tao_any_destructor (void *x)
+{
+  HomeDefSeq *tmp = ACE_static_cast (HomeDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_HomeDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f48), ACE_NTOHL (0x6f6d6544), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/HomeDefSeq:1.0
+  11, ACE_NTOHL (0x486f6d65), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = HomeDefSeq
+  CORBA::tk_sequence, // typecode kind
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    48, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f48), ACE_NTOHL (0x6f6d6544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/HomeDef:1.0
+      8, ACE_NTOHL (0x486f6d65), ACE_NTOHL (0x44656600),  // name = HomeDef
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_HomeDefSeq (CORBA::tk_alias, sizeof (_oc_IR_HomeDefSeq), (char *) &_oc_IR_HomeDefSeq, 0, sizeof (IR::HomeDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HomeDefSeq, &_tc_TAO_tc_IR_HomeDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::EmitsDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::EmitsDef **old = ACE_reinterpret_cast (IR::EmitsDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::EmitsDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-    CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);
+    IR::EmitsDef **tmp = ACE_reinterpret_cast (IR::EmitsDef**, this->buffer_);
     for (CORBA::ULong i = 0; i < this->length_; ++i)
     {
       CORBA::release (tmp[i]);
-      tmp[i] = CORBA_Contained::_nil ();
+      tmp[i] = IR::EmitsDef::_nil ();
     }
-    _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (tmp);
+    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::freebuf (tmp);
     this->buffer_ = 0;
   }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::~_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::EmitsDef **tmp = ACE_reinterpret_cast (IR::EmitsDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::EmitsDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::EmitsDef **tmp = ACE_static_cast (IR::EmitsDef**, target);
+    *tmp = IR::EmitsDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_upcast (void *src) const
+  {
+    IR::EmitsDef **tmp = ACE_static_cast (IR::EmitsDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EMITSDEFSEQ_CS_)
+#define _IR_EMITSDEFSEQ_CS_
+
+// *************************************************************
+// IR::EmitsDefSeq
+// *************************************************************
+
+IR::EmitsDefSeq::EmitsDefSeq (void)
+{}
+IR::EmitsDefSeq::EmitsDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::EmitsDef,IR::EmitsDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::EmitsDefSeq::EmitsDefSeq (CORBA::ULong max, CORBA::ULong length, IR::EmitsDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::EmitsDef,IR::EmitsDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::EmitsDefSeq::EmitsDefSeq (const EmitsDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::EmitsDef,IR::EmitsDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::EmitsDefSeq::~EmitsDefSeq (void) // dtor
+{}
+void IR::EmitsDefSeq::_tao_any_destructor (void *x)
+{
+  EmitsDefSeq *tmp = ACE_static_cast (EmitsDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_EmitsDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/EmitsDefSeq:1.0
+  12, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x53657100),  // name = EmitsDefSeq
+  CORBA::tk_sequence, // typecode kind
+  68, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    52, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EmitsDef:1.0
+      9, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = EmitsDef
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_EmitsDefSeq (CORBA::tk_alias, sizeof (_oc_IR_EmitsDefSeq), (char *) &_oc_IR_EmitsDefSeq, 0, sizeof (IR::EmitsDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EmitsDefSeq, &_tc_TAO_tc_IR_EmitsDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CS_
 
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::PublishesDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::PublishesDef **old = ACE_reinterpret_cast (IR::PublishesDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::PublishesDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::PublishesDef **tmp = ACE_reinterpret_cast (IR::PublishesDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::PublishesDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void)
   {
     this->_deallocate_buffer ();
   }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::PublishesDef **tmp = ACE_reinterpret_cast (IR::PublishesDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::PublishesDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::PublishesDef **tmp = ACE_static_cast (IR::PublishesDef**, target);
+    *tmp = IR::PublishesDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_upcast (void *src) const
+  {
+    IR::PublishesDef **tmp = ACE_static_cast (IR::PublishesDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PUBLISHESDEFSEQ_CS_)
+#define _IR_PUBLISHESDEFSEQ_CS_
+
+// *************************************************************
+// IR::PublishesDefSeq
+// *************************************************************
+
+IR::PublishesDefSeq::PublishesDefSeq (void)
+{}
+IR::PublishesDefSeq::PublishesDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::PublishesDef,IR::PublishesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::PublishesDefSeq::PublishesDefSeq (CORBA::ULong max, CORBA::ULong length, IR::PublishesDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::PublishesDef,IR::PublishesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::PublishesDefSeq::PublishesDefSeq (const PublishesDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::PublishesDef,IR::PublishesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::PublishesDefSeq::~PublishesDefSeq (void) // dtor
+{}
+void IR::PublishesDefSeq::_tao_any_destructor (void *x)
+{
+  PublishesDefSeq *tmp = ACE_static_cast (PublishesDefSeq*,x);
+  delete tmp;
+}
+
 
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_PublishesDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/PublishesDefSeq:1.0
+  16, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x53657100),  // name = PublishesDefSeq
+  CORBA::tk_sequence, // typecode kind
+  76, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    60, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PublishesDef:1.0
+      13, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = PublishesDef
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_PublishesDefSeq (CORBA::tk_alias, sizeof (_oc_IR_PublishesDefSeq), (char *) &_oc_IR_PublishesDefSeq, 0, sizeof (IR::PublishesDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PublishesDefSeq, &_tc_TAO_tc_IR_PublishesDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::ConsumesDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::ConsumesDef **old = ACE_reinterpret_cast (IR::ConsumesDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::ConsumesDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::ConsumesDef **tmp = ACE_reinterpret_cast (IR::ConsumesDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ConsumesDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::ConsumesDef **tmp = ACE_reinterpret_cast (IR::ConsumesDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ConsumesDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::ConsumesDef **tmp = ACE_static_cast (IR::ConsumesDef**, target);
+    *tmp = IR::ConsumesDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_upcast (void *src) const
   {
-    CORBA_Contained **tmp = ACE_reinterpret_cast (CORBA_Contained**, this->buffer_);
+    IR::ConsumesDef **tmp = ACE_static_cast (IR::ConsumesDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
 
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_CONSUMESDEFSEQ_CS_)
+#define _IR_CONSUMESDEFSEQ_CS_
+
+// *************************************************************
+// IR::ConsumesDefSeq
+// *************************************************************
+
+IR::ConsumesDefSeq::ConsumesDefSeq (void)
+{}
+IR::ConsumesDefSeq::ConsumesDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ConsumesDef,IR::ConsumesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ConsumesDefSeq::ConsumesDefSeq (CORBA::ULong max, CORBA::ULong length, IR::ConsumesDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ConsumesDef,IR::ConsumesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ConsumesDefSeq::ConsumesDefSeq (const ConsumesDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ConsumesDef,IR::ConsumesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ConsumesDefSeq::~ConsumesDefSeq (void) // dtor
+{}
+void IR::ConsumesDefSeq::_tao_any_destructor (void *x)
+{
+  ConsumesDefSeq *tmp = ACE_static_cast (ConsumesDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ConsumesDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ConsumesDefSeq:1.0
+  15, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = ConsumesDefSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConsumesDef:1.0
+      12, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656600),  // name = ConsumesDef
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ConsumesDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ConsumesDefSeq), (char *) &_oc_IR_ConsumesDefSeq, 0, sizeof (IR::ConsumesDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConsumesDefSeq, &_tc_TAO_tc_IR_ConsumesDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::FactoryDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::FactoryDef **old = ACE_reinterpret_cast (IR::FactoryDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::FactoryDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::FactoryDef **tmp = ACE_reinterpret_cast (IR::FactoryDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::FactoryDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::~_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::FactoryDef **tmp = ACE_reinterpret_cast (IR::FactoryDef**, this->buffer_);
+    
     for (CORBA::ULong i = nl; i < ol; ++i)
     {
       CORBA::release (tmp[i]);
-      tmp[i] = CORBA_Contained::_nil ();
+      tmp[i] = IR::FactoryDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::FactoryDef **tmp = ACE_static_cast (IR::FactoryDef**, target);
+    *tmp = IR::FactoryDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_upcast (void *src) const
+  {
+    IR::FactoryDef **tmp = ACE_static_cast (IR::FactoryDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_FACTORYDEFSEQ_CS_)
+#define _IR_FACTORYDEFSEQ_CS_
+
+// *************************************************************
+// IR::FactoryDefSeq
+// *************************************************************
+
+IR::FactoryDefSeq::FactoryDefSeq (void)
+{}
+IR::FactoryDefSeq::FactoryDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FactoryDef,IR::FactoryDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::FactoryDefSeq::FactoryDefSeq (CORBA::ULong max, CORBA::ULong length, IR::FactoryDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FactoryDef,IR::FactoryDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::FactoryDefSeq::FactoryDefSeq (const FactoryDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FactoryDef,IR::FactoryDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::FactoryDefSeq::~FactoryDefSeq (void) // dtor
+{}
+void IR::FactoryDefSeq::_tao_any_destructor (void *x)
+{
+  FactoryDefSeq *tmp = ACE_static_cast (FactoryDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_FactoryDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x66536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FactoryDefSeq:1.0
+  14, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65665365), ACE_NTOHL (0x71000000),  // name = FactoryDefSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/FactoryDef:1.0
+      11, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65660000),  // name = FactoryDef
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_FactoryDefSeq (CORBA::tk_alias, sizeof (_oc_IR_FactoryDefSeq), (char *) &_oc_IR_FactoryDefSeq, 0, sizeof (IR::FactoryDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FactoryDefSeq, &_tc_TAO_tc_IR_FactoryDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::FinderDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::FinderDef **old = ACE_reinterpret_cast (IR::FinderDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::FinderDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::FinderDef **tmp = ACE_reinterpret_cast (IR::FinderDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::FinderDef::_nil ();
     }
+    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::~_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void)
+  {
+    this->_deallocate_buffer ();
   }
+  
   void
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_downcast (
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::FinderDef **tmp = ACE_reinterpret_cast (IR::FinderDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::FinderDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_downcast (
       void* target,
       CORBA_Object *src,
       CORBA_Environment &ACE_TRY_ENV
     )
   {
-    CORBA_Contained **tmp = ACE_static_cast (CORBA_Contained**, target);
-    *tmp = CORBA_Contained::_narrow (src, ACE_TRY_ENV);
+    IR::FinderDef **tmp = ACE_static_cast (IR::FinderDef**, target);
+    *tmp = IR::FinderDef::_narrow (src, ACE_TRY_ENV);
   }
 
   CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_upcast (void *src) const
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_upcast (void *src) const
   {
-    CORBA_Contained **tmp = ACE_static_cast (CORBA_Contained**, src);
+    IR::FinderDef **tmp = ACE_static_cast (IR::FinderDef**, src);
     return *tmp;
   }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_FINDERDEFSEQ_CS_)
+#define _IR_FINDERDEFSEQ_CS_
+
+// *************************************************************
+// IR::FinderDefSeq
+// *************************************************************
+
+IR::FinderDefSeq::FinderDefSeq (void)
+{}
+IR::FinderDefSeq::FinderDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FinderDef,IR::FinderDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::FinderDefSeq::FinderDefSeq (CORBA::ULong max, CORBA::ULong length, IR::FinderDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FinderDef,IR::FinderDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::FinderDefSeq::FinderDefSeq (const FinderDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::FinderDef,IR::FinderDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::FinderDefSeq::~FinderDefSeq (void) // dtor
+{}
+void IR::FinderDefSeq::_tao_any_destructor (void *x)
+{
+  FinderDefSeq *tmp = ACE_static_cast (FinderDefSeq*,x);
+  delete tmp;
+}
+
 
 #endif /* end #if !defined */
 
+static const CORBA::Long _oc_IR_FinderDefSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/FinderDefSeq:1.0
+  13, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66536571), ACE_NTOHL (0x0),  // name = FinderDefSeq
+  CORBA::tk_sequence, // typecode kind
+  72, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    56, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FinderDef:1.0
+      10, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66000000),  // name = FinderDef
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+    0U,
 
-#if !defined (_CORBA_CONTAINEDSEQ_CS_)
-#define _CORBA_CONTAINEDSEQ_CS_
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_FinderDefSeq (CORBA::tk_alias, sizeof (_oc_IR_FinderDefSeq), (char *) &_oc_IR_FinderDefSeq, 0, sizeof (IR::FinderDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FinderDefSeq, &_tc_TAO_tc_IR_FinderDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONTAINEDSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONTAINEDSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::Contained **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::Contained **old = ACE_reinterpret_cast (IR::Contained**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::Contained::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::Contained **tmp = ACE_reinterpret_cast (IR::Contained**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::Contained::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::~_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::Contained **tmp = ACE_reinterpret_cast (IR::Contained**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::Contained::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::Contained **tmp = ACE_static_cast (IR::Contained**, target);
+    *tmp = IR::Contained::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_upcast (void *src) const
+  {
+    IR::Contained **tmp = ACE_static_cast (IR::Contained**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_CONTAINEDSEQ_CS_)
+#define _IR_CONTAINEDSEQ_CS_
 
 // *************************************************************
-// CORBA_ContainedSeq
+// IR::ContainedSeq
 // *************************************************************
 
-CORBA_ContainedSeq::CORBA_ContainedSeq (void)
+IR::ContainedSeq::ContainedSeq (void)
 {}
-CORBA_ContainedSeq::CORBA_ContainedSeq (CORBA::ULong max) // uses max size
-  :
+IR::ContainedSeq::ContainedSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq
+  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_Contained,CORBA_Contained_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::Contained,IR::Contained_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_ContainedSeq::CORBA_ContainedSeq (CORBA::ULong max, CORBA::ULong length, CORBA_Contained_ptr *buffer, CORBA::Boolean release)
-  :
+IR::ContainedSeq::ContainedSeq (CORBA::ULong max, CORBA::ULong length, IR::Contained_ptr *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq
+  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_Contained,CORBA_Contained_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::Contained,IR::Contained_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_ContainedSeq::CORBA_ContainedSeq (const CORBA_ContainedSeq &seq) // copy ctor
-  :
+IR::ContainedSeq::ContainedSeq (const ContainedSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq
+  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_Contained,CORBA_Contained_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::Contained,IR::Contained_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_ContainedSeq::~CORBA_ContainedSeq (void) // dtor
+IR::ContainedSeq::~ContainedSeq (void) // dtor
 {}
+void IR::ContainedSeq::_tao_any_destructor (void *x)
+{
+  ContainedSeq *tmp = ACE_static_cast (ContainedSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_ContainedSeq[] =
+static const CORBA::Long _oc_IR_ContainedSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e656453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContainedSeq:1.0
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContainedSeq:1.0
   13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContainedSeq
   CORBA::tk_sequence, // typecode kind
   72, // encapsulation length
@@ -1497,397 +4075,479 @@ static const CORBA::Long _oc_CORBA_ContainedSeq[] =
     CORBA::tk_objref, // typecode kind
     56, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e65643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained:1.0
+      29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained:1.0
       10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64000000),  // name = Contained
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ContainedSeq (CORBA::tk_alias, sizeof (_oc_CORBA_ContainedSeq), (char *) &_oc_CORBA_ContainedSeq, 0, sizeof (CORBA_ContainedSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_ContainedSeq (CORBA::tk_alias, sizeof (_oc_IR_ContainedSeq), (char *) &_oc_IR_ContainedSeq, 0, sizeof (IR::ContainedSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContainedSeq, &_tc_TAO_tc_CORBA_ContainedSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContainedSeq, &_tc_TAO_tc_IR_ContainedSeq)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_StructMember[] =
+static const CORBA::Long _oc_IR_StructMember[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
   13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = StructMember
   3, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
   CORBA::tk_TypeCode,
 
   9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
   CORBA::tk_objref, // typecode kind
-  52, // encapsulation length
+  48, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+    27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
     8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_StructMember (CORBA::tk_struct, sizeof (_oc_CORBA_StructMember), (char *) &_oc_CORBA_StructMember, 0, sizeof (CORBA_StructMember));
+static CORBA::TypeCode _tc_TAO_tc_IR_StructMember (CORBA::tk_struct, sizeof (_oc_IR_StructMember), (char *) &_oc_IR_StructMember, 0, sizeof (IR::StructMember));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructMember, &_tc_TAO_tc_CORBA_StructMember)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructMember, &_tc_TAO_tc_IR_StructMember)
 TAO_NAMESPACE_END
+void IR::StructMember::_tao_any_destructor (void *x)
+{
+  StructMember *tmp = ACE_static_cast (StructMember*,x);
+  delete tmp;
+}
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CS_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_STRUCTMEMBERSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_STRUCTMEMBERSEQ_CS_
 
   void
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_StructMember* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (length);
-
+    IR::StructMember* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_StructMember *old = ACE_reinterpret_cast (CORBA_StructMember *,this->buffer_);
-
+      IR::StructMember *old = ACE_reinterpret_cast (IR::StructMember *,this->buffer_);
+      
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-
+      
       if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (old);
-
+        _TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (old);
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-
-    CORBA_StructMember *tmp = ACE_reinterpret_cast (CORBA_StructMember *,this->buffer_);
-
-    _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
+    
+    IR::StructMember *tmp = ACE_reinterpret_cast (IR::StructMember *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (tmp);
     this->buffer_ = 0;
-  }
-
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::~_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Dtor.
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::~_TAO_Unbounded_Sequence_IR_StructMemberSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-
-
+  
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_STRUCTMEMBERSEQ_CS_)
-#define _CORBA_STRUCTMEMBERSEQ_CS_
+#if !defined (_IR_STRUCTMEMBERSEQ_CS_)
+#define _IR_STRUCTMEMBERSEQ_CS_
 
 // *************************************************************
-// CORBA_StructMemberSeq
+// IR::StructMemberSeq
 // *************************************************************
 
-CORBA_StructMemberSeq::CORBA_StructMemberSeq (void)
+IR::StructMemberSeq::StructMemberSeq (void)
 {}
-CORBA_StructMemberSeq::CORBA_StructMemberSeq (CORBA::ULong max) // uses max size
-  :
+IR::StructMemberSeq::StructMemberSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq
+  _TAO_Unbounded_Sequence_IR_StructMemberSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_StructMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::StructMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_StructMemberSeq::CORBA_StructMemberSeq (CORBA::ULong max, CORBA::ULong length, CORBA_StructMember *buffer, CORBA::Boolean release)
-  :
+IR::StructMemberSeq::StructMemberSeq (CORBA::ULong max, CORBA::ULong length, IR::StructMember *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq
+  _TAO_Unbounded_Sequence_IR_StructMemberSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_StructMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::StructMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_StructMemberSeq::CORBA_StructMemberSeq (const CORBA_StructMemberSeq &seq) // copy ctor
-  :
+IR::StructMemberSeq::StructMemberSeq (const StructMemberSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq
+  _TAO_Unbounded_Sequence_IR_StructMemberSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_StructMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::StructMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_StructMemberSeq::~CORBA_StructMemberSeq (void) // dtor
+IR::StructMemberSeq::~StructMemberSeq (void) // dtor
 {}
+void IR::StructMemberSeq::_tao_any_destructor (void *x)
+{
+  StructMemberSeq *tmp = ACE_static_cast (StructMemberSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_StructMemberSeq[] =
+static const CORBA::Long _oc_IR_StructMemberSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/StructMemberSeq:1.0
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/StructMemberSeq:1.0
   16, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x53657100),  // name = StructMemberSeq
   CORBA::tk_sequence, // typecode kind
-  264, // encapsulation length
+  320, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
-    248, // encapsulation length
+    304, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
       13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = StructMember
       3, // member count
       5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      132, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
         11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
 
       5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
       CORBA::tk_TypeCode,
 
       9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
       CORBA::tk_objref, // typecode kind
-      52, // encapsulation length
+      48, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
         8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_StructMemberSeq (CORBA::tk_alias, sizeof (_oc_CORBA_StructMemberSeq), (char *) &_oc_CORBA_StructMemberSeq, 0, sizeof (CORBA_StructMemberSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_StructMemberSeq (CORBA::tk_alias, sizeof (_oc_IR_StructMemberSeq), (char *) &_oc_IR_StructMemberSeq, 0, sizeof (IR::StructMemberSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructMemberSeq, &_tc_TAO_tc_CORBA_StructMemberSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructMemberSeq, &_tc_TAO_tc_IR_StructMemberSeq)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_Initializer[] =
+static const CORBA::Long _oc_IR_Initializer[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x69746961), ACE_NTOHL (0x6c697a65), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/Initializer:1.0
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/Initializer:1.0
   12, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657200),  // name = Initializer
-  1, // member count
+  2, // member count
   8, ACE_NTOHL (0x6d656d62), ACE_NTOHL (0x65727300),  // name = members
   CORBA::tk_alias, // typecode kind for typedefs
-  340, // encapsulation length
+  392, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/StructMemberSeq:1.0
+    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/StructMemberSeq:1.0
     16, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x53657100),  // name = StructMemberSeq
     CORBA::tk_sequence, // typecode kind
-    264, // encapsulation length
+    320, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_struct, // typecode kind
-      248, // encapsulation length
+      304, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
         13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = StructMember
         3, // member count
         5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        132, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
           11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
 
         5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
         CORBA::tk_TypeCode,
 
         9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
         CORBA::tk_objref, // typecode kind
-        52, // encapsulation length
+        48, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+          27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
           8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
 
       0U,
 
 
+  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  132, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
+
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_Initializer (CORBA::tk_struct, sizeof (_oc_CORBA_Initializer), (char *) &_oc_CORBA_Initializer, 0, sizeof (CORBA_Initializer));
+static CORBA::TypeCode _tc_TAO_tc_IR_Initializer (CORBA::tk_struct, sizeof (_oc_IR_Initializer), (char *) &_oc_IR_Initializer, 0, sizeof (IR::Initializer));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Initializer, &_tc_TAO_tc_CORBA_Initializer)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Initializer, &_tc_TAO_tc_IR_Initializer)
 TAO_NAMESPACE_END
+void IR::Initializer::_tao_any_destructor (void *x)
+{
+  Initializer *tmp = ACE_static_cast (Initializer*,x);
+  delete tmp;
+}
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CS_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_INITIALIZERSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_INITIALIZERSEQ_CS_
 
   void
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_Initializer* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (length);
-
+    IR::Initializer* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_Initializer *old = ACE_reinterpret_cast (CORBA_Initializer *,this->buffer_);
-
+      IR::Initializer *old = ACE_reinterpret_cast (IR::Initializer *,this->buffer_);
+      
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-
+      
       if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (old);
-
+        _TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (old);
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-
-    CORBA_Initializer *tmp = ACE_reinterpret_cast (CORBA_Initializer *,this->buffer_);
-
-    _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
+    
+    IR::Initializer *tmp = ACE_reinterpret_cast (IR::Initializer *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (tmp);
     this->buffer_ = 0;
-  }
-
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::~_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Dtor.
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::~_TAO_Unbounded_Sequence_IR_InitializerSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-
-
+  
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_INITIALIZERSEQ_CS_)
-#define _CORBA_INITIALIZERSEQ_CS_
+#if !defined (_IR_INITIALIZERSEQ_CS_)
+#define _IR_INITIALIZERSEQ_CS_
 
 // *************************************************************
-// CORBA_InitializerSeq
+// IR::InitializerSeq
 // *************************************************************
 
-CORBA_InitializerSeq::CORBA_InitializerSeq (void)
+IR::InitializerSeq::InitializerSeq (void)
 {}
-CORBA_InitializerSeq::CORBA_InitializerSeq (CORBA::ULong max) // uses max size
-  :
+IR::InitializerSeq::InitializerSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq
+  _TAO_Unbounded_Sequence_IR_InitializerSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_Initializer>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::Initializer>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_InitializerSeq::CORBA_InitializerSeq (CORBA::ULong max, CORBA::ULong length, CORBA_Initializer *buffer, CORBA::Boolean release)
-  :
+IR::InitializerSeq::InitializerSeq (CORBA::ULong max, CORBA::ULong length, IR::Initializer *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq
+  _TAO_Unbounded_Sequence_IR_InitializerSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_Initializer>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::Initializer>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_InitializerSeq::CORBA_InitializerSeq (const CORBA_InitializerSeq &seq) // copy ctor
-  :
+IR::InitializerSeq::InitializerSeq (const InitializerSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq
+  _TAO_Unbounded_Sequence_IR_InitializerSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_Initializer>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::Initializer>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_InitializerSeq::~CORBA_InitializerSeq (void) // dtor
+IR::InitializerSeq::~InitializerSeq (void) // dtor
 {}
+void IR::InitializerSeq::_tao_any_destructor (void *x)
+{
+  InitializerSeq *tmp = ACE_static_cast (InitializerSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_InitializerSeq[] =
+static const CORBA::Long _oc_IR_InitializerSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x69746961), ACE_NTOHL (0x6c697a65), ACE_NTOHL (0x72536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/InitializerSeq:1.0
+  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/InitializerSeq:1.0
   15, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657253), ACE_NTOHL (0x65710000),  // name = InitializerSeq
   CORBA::tk_sequence, // typecode kind
-  440, // encapsulation length
+  640, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
-    424, // encapsulation length
+    624, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x69746961), ACE_NTOHL (0x6c697a65), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/Initializer:1.0
+      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/Initializer:1.0
       12, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657200),  // name = Initializer
-      1, // member count
+      2, // member count
       8, ACE_NTOHL (0x6d656d62), ACE_NTOHL (0x65727300),  // name = members
       CORBA::tk_alias, // typecode kind for typedefs
-      340, // encapsulation length
+      392, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/StructMemberSeq:1.0
+        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/StructMemberSeq:1.0
         16, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x53657100),  // name = StructMemberSeq
         CORBA::tk_sequence, // typecode kind
-        264, // encapsulation length
+        320, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
           CORBA::tk_struct, // typecode kind
-          248, // encapsulation length
+          304, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
-            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+            32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
             13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = StructMember
             3, // member count
             5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
             CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
+            132, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
               11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string,
-              0U, // string length
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
 
             5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
             CORBA::tk_TypeCode,
 
             9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
             CORBA::tk_objref, // typecode kind
-            52, // encapsulation length
+            48, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+              27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
               8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
 
           0U,
 
 
+      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      132, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_InitializerSeq (CORBA::tk_alias, sizeof (_oc_CORBA_InitializerSeq), (char *) &_oc_CORBA_InitializerSeq, 0, sizeof (CORBA_InitializerSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_InitializerSeq (CORBA::tk_alias, sizeof (_oc_IR_InitializerSeq), (char *) &_oc_IR_InitializerSeq, 0, sizeof (IR::InitializerSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InitializerSeq, &_tc_TAO_tc_CORBA_InitializerSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InitializerSeq, &_tc_TAO_tc_IR_InitializerSeq)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_UnionMember[] =
+static const CORBA::Long _oc_IR_UnionMember[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f556e), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/UnionMember:1.0
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UnionMember:1.0
   12, ACE_NTOHL (0x556e696f), ACE_NTOHL (0x6e4d656d), ACE_NTOHL (0x62657200),  // name = UnionMember
   4, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   6, ACE_NTOHL (0x6c616265), ACE_NTOHL (0x6c000000),  // name = label
   CORBA::tk_any,
@@ -1897,130 +4557,147 @@ static const CORBA::Long _oc_CORBA_UnionMember[] =
 
   9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
   CORBA::tk_objref, // typecode kind
-  52, // encapsulation length
+  48, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+    27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
     8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_UnionMember (CORBA::tk_struct, sizeof (_oc_CORBA_UnionMember), (char *) &_oc_CORBA_UnionMember, 0, sizeof (CORBA_UnionMember));
+static CORBA::TypeCode _tc_TAO_tc_IR_UnionMember (CORBA::tk_struct, sizeof (_oc_IR_UnionMember), (char *) &_oc_IR_UnionMember, 0, sizeof (IR::UnionMember));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionMember, &_tc_TAO_tc_CORBA_UnionMember)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionMember, &_tc_TAO_tc_IR_UnionMember)
 TAO_NAMESPACE_END
+void IR::UnionMember::_tao_any_destructor (void *x)
+{
+  UnionMember *tmp = ACE_static_cast (UnionMember*,x);
+  delete tmp;
+}
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CS_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_UNIONMEMBERSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_UNIONMEMBERSEQ_CS_
 
   void
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_UnionMember* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (length);
-
+    IR::UnionMember* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_UnionMember *old = ACE_reinterpret_cast (CORBA_UnionMember *,this->buffer_);
-
+      IR::UnionMember *old = ACE_reinterpret_cast (IR::UnionMember *,this->buffer_);
+      
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-
+      
       if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (old);
-
+        _TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (old);
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-
-    CORBA_UnionMember *tmp = ACE_reinterpret_cast (CORBA_UnionMember *,this->buffer_);
-
-    _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
+    
+    IR::UnionMember *tmp = ACE_reinterpret_cast (IR::UnionMember *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (tmp);
     this->buffer_ = 0;
-  }
-
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::~_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Dtor.
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::~_TAO_Unbounded_Sequence_IR_UnionMemberSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-
-
+  
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_UNIONMEMBERSEQ_CS_)
-#define _CORBA_UNIONMEMBERSEQ_CS_
+#if !defined (_IR_UNIONMEMBERSEQ_CS_)
+#define _IR_UNIONMEMBERSEQ_CS_
 
 // *************************************************************
-// CORBA_UnionMemberSeq
+// IR::UnionMemberSeq
 // *************************************************************
 
-CORBA_UnionMemberSeq::CORBA_UnionMemberSeq (void)
+IR::UnionMemberSeq::UnionMemberSeq (void)
 {}
-CORBA_UnionMemberSeq::CORBA_UnionMemberSeq (CORBA::ULong max) // uses max size
-  :
+IR::UnionMemberSeq::UnionMemberSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq
+  _TAO_Unbounded_Sequence_IR_UnionMemberSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_UnionMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::UnionMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_UnionMemberSeq::CORBA_UnionMemberSeq (CORBA::ULong max, CORBA::ULong length, CORBA_UnionMember *buffer, CORBA::Boolean release)
-  :
+IR::UnionMemberSeq::UnionMemberSeq (CORBA::ULong max, CORBA::ULong length, IR::UnionMember *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq
+  _TAO_Unbounded_Sequence_IR_UnionMemberSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_UnionMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::UnionMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_UnionMemberSeq::CORBA_UnionMemberSeq (const CORBA_UnionMemberSeq &seq) // copy ctor
-  :
+IR::UnionMemberSeq::UnionMemberSeq (const UnionMemberSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq
+  _TAO_Unbounded_Sequence_IR_UnionMemberSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_UnionMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::UnionMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_UnionMemberSeq::~CORBA_UnionMemberSeq (void) // dtor
+IR::UnionMemberSeq::~UnionMemberSeq (void) // dtor
 {}
+void IR::UnionMemberSeq::_tao_any_destructor (void *x)
+{
+  UnionMemberSeq *tmp = ACE_static_cast (UnionMemberSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_UnionMemberSeq[] =
+static const CORBA::Long _oc_IR_UnionMemberSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f556e), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x72536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/UnionMemberSeq:1.0
+  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/UnionMemberSeq:1.0
   15, ACE_NTOHL (0x556e696f), ACE_NTOHL (0x6e4d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65710000),  // name = UnionMemberSeq
   CORBA::tk_sequence, // typecode kind
-  276, // encapsulation length
+  332, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
-    260, // encapsulation length
+    316, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f556e), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/UnionMember:1.0
+      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UnionMember:1.0
       12, ACE_NTOHL (0x556e696f), ACE_NTOHL (0x6e4d656d), ACE_NTOHL (0x62657200),  // name = UnionMember
       4, // member count
       5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      132, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
         11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
 
       6, ACE_NTOHL (0x6c616265), ACE_NTOHL (0x6c000000),  // name = label
       CORBA::tk_any,
@@ -2030,151 +4707,164 @@ static const CORBA::Long _oc_CORBA_UnionMemberSeq[] =
 
       9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
       CORBA::tk_objref, // typecode kind
-      52, // encapsulation length
+      48, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
         8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_UnionMemberSeq (CORBA::tk_alias, sizeof (_oc_CORBA_UnionMemberSeq), (char *) &_oc_CORBA_UnionMemberSeq, 0, sizeof (CORBA_UnionMemberSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_UnionMemberSeq (CORBA::tk_alias, sizeof (_oc_IR_UnionMemberSeq), (char *) &_oc_IR_UnionMemberSeq, 0, sizeof (IR::UnionMemberSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionMemberSeq, &_tc_TAO_tc_CORBA_UnionMemberSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionMemberSeq, &_tc_TAO_tc_IR_UnionMemberSeq)
 TAO_NAMESPACE_END
 
-#if !defined (_CORBA_ENUMMEMBERSEQ_CS_)
-#define _CORBA_ENUMMEMBERSEQ_CS_
+#if !defined (_IR_ENUMMEMBERSEQ_CS_)
+#define _IR_ENUMMEMBERSEQ_CS_
 
 // *************************************************************
-// CORBA_EnumMemberSeq
+// IR::EnumMemberSeq
 // *************************************************************
 
-CORBA_EnumMemberSeq::CORBA_EnumMemberSeq (void)
+IR::EnumMemberSeq::EnumMemberSeq (void)
 {}
-CORBA_EnumMemberSeq::CORBA_EnumMemberSeq (CORBA::ULong max) // uses max size
-  :
+IR::EnumMemberSeq::EnumMemberSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_EnumMemberSeq::CORBA_EnumMemberSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
-  :
+IR::EnumMemberSeq::EnumMemberSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_EnumMemberSeq::CORBA_EnumMemberSeq (const CORBA_EnumMemberSeq &seq) // copy ctor
-  :
+IR::EnumMemberSeq::EnumMemberSeq (const EnumMemberSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_EnumMemberSeq::~CORBA_EnumMemberSeq (void) // dtor
+IR::EnumMemberSeq::~EnumMemberSeq (void) // dtor
 {}
+void IR::EnumMemberSeq::_tao_any_destructor (void *x)
+{
+  EnumMemberSeq *tmp = ACE_static_cast (EnumMemberSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_EnumMemberSeq[] =
+static const CORBA::Long _oc_IR_EnumMemberSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f456e), ACE_NTOHL (0x756d4d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/EnumMemberSeq:1.0
+  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6e756d4d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x72536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/EnumMemberSeq:1.0
   14, ACE_NTOHL (0x456e756d), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x71000000),  // name = EnumMemberSeq
   CORBA::tk_sequence, // typecode kind
-  84, // encapsulation length
+  148, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_alias, // typecode kind for typedefs
-    68, // encapsulation length
+    132, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
       11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-      CORBA::tk_string,
-      0U, // string length
+      CORBA::tk_alias, // typecode kind for typedefs
+      68, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_string, 
+        0U, // string length
+
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_EnumMemberSeq (CORBA::tk_alias, sizeof (_oc_CORBA_EnumMemberSeq), (char *) &_oc_CORBA_EnumMemberSeq, 0, sizeof (CORBA_EnumMemberSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_EnumMemberSeq (CORBA::tk_alias, sizeof (_oc_IR_EnumMemberSeq), (char *) &_oc_IR_EnumMemberSeq, 0, sizeof (IR::EnumMemberSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnumMemberSeq, &_tc_TAO_tc_CORBA_EnumMemberSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnumMemberSeq, &_tc_TAO_tc_IR_EnumMemberSeq)
 TAO_NAMESPACE_END
-CORBA_Container_ptr CORBA_Container::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::Container::_tao_any_destructor (void *x)
+{
+  Container *tmp = ACE_static_cast (Container*,x);
+  CORBA::release (tmp);
+}
+
+IR::Container_ptr IR::Container::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_Container::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Container:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_Container::_nil ());
+    return Container::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/Container:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (Container::_nil ());
   if (is_a == 0)
-    return CORBA_Container::_nil ();
-  return CORBA_Container::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return Container::_nil ();
+  return Container::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_Container_ptr CORBA_Container::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::Container_ptr IR::Container::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_Container::_nil ();
+    return Container::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_Container_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  Container_ptr default_proxy = Container::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_Container_Stub_Factory_function_pointer != 0)
     {
-      CORBA_Container_ptr retv = _TAO_collocation_CORBA_Container_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_Container_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_Container_ptr retval = CORBA_Container::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_Container (stub),
-                  CORBA_Container::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, Container (stub), Container::_nil ());
+  return TAO_IR_Container_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_Container_ptr
-CORBA_Container::_duplicate (CORBA_Container_ptr obj)
+IR::Container_ptr 
+IR::Container::_duplicate (Container_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA_Contained_ptr CORBA_Container::lookup (
+IR::Contained_ptr IR::Container::lookup (
     const char * search_name,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_Contained_ptr _tao_retval = CORBA_Contained::_nil ();
-
-
+  
+  IR::Contained_ptr _tao_retval = IR::Contained::_nil ();
+  IR::Contained_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "lookup",
@@ -2182,67 +4872,126 @@ CORBA_Contained_ptr CORBA_Container::lookup (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << search_name)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "lookup",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << search_name)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "lookup",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "lookup",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_ContainedSeq * CORBA_Container::contents (
-   CORBA::DefinitionKind limit_type,
+IR::ContainedSeq * IR::Container::contents (
+    IR::DefinitionKind limit_type,
     CORBA::Boolean exclude_inherited,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_ContainedSeq* _tao_retval = 0;
-
-
+  
+  IR::ContainedSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-  ACE_NEW_RETURN (_tao_retval, CORBA_ContainedSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ContainedSeq, _tao_retval);
+  IR::ContainedSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "contents",
@@ -2250,70 +4999,129 @@ CORBA_ContainedSeq * CORBA_Container::contents (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << limit_type) &&
-          (_tao_out << CORBA_Any::from_boolean (exclude_inherited))
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "contents",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << limit_type) &&
+              (_tao_out << CORBA::Any::from_boolean (exclude_inherited))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "contents",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "contents",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_ContainedSeq * CORBA_Container::lookup_name (
+IR::ContainedSeq * IR::Container::lookup_name (
     const char * search_name,
     CORBA::Long levels_to_search,
-   CORBA::DefinitionKind limit_type,
+    IR::DefinitionKind limit_type,
     CORBA::Boolean exclude_inherited,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_ContainedSeq* _tao_retval = 0;
-
-
+  
+  IR::ContainedSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_ContainedSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ContainedSeq, _tao_retval);
+  IR::ContainedSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "lookup_name",
@@ -2321,71 +5129,129 @@ CORBA_ContainedSeq * CORBA_Container::lookup_name (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << search_name) &&
-          (_tao_out << levels_to_search) &&
-          (_tao_out << limit_type) &&
-          (_tao_out << CORBA_Any::from_boolean (exclude_inherited))
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "lookup_name",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << search_name) &&
+              (_tao_out << levels_to_search) &&
+              (_tao_out << limit_type) &&
+              (_tao_out << CORBA::Any::from_boolean (exclude_inherited))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "lookup_name",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "lookup_name",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-static const CORBA::Long _oc_CORBA_Container_Description[] =
+static const CORBA::Long _oc_IR_Container_Description[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  44, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e65722f), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Container/Description:1.0
+  41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6572), ACE_NTOHL (0x2f446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Container/Description:1.0
   12, ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = Description
   3, // member count
   17, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x645f6f62), ACE_NTOHL (0x6a656374), ACE_NTOHL (0x0),  // name = contained_object
   CORBA::tk_objref, // typecode kind
   56, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e65643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained:1.0
+    29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained:1.0
     10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64000000),  // name = Contained
 
   5, ACE_NTOHL (0x6b696e64), ACE_NTOHL (0x0),  // name = kind
   CORBA::tk_enum, // typecode kind
-  472, // encapsulation length
+  632, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4465), ACE_NTOHL (0x66696e69), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4b696e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/DefinitionKind:1.0
+    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f44), ACE_NTOHL (0x6566696e), ACE_NTOHL (0x6974696f), ACE_NTOHL (0x6e4b696e), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/DefinitionKind:1.0
     15, ACE_NTOHL (0x44656669), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x6f6e4b69), ACE_NTOHL (0x6e640000),  // name = DefinitionKind
-    24, // member count
+    34, // member count
     8, ACE_NTOHL (0x646b5f6e), ACE_NTOHL (0x6f6e6500),  // name = dk_none
     7, ACE_NTOHL (0x646b5f61), ACE_NTOHL (0x6c6c0000),  // name = dk_all
     13, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x0),  // name = dk_Attribute
@@ -2410,133 +5276,154 @@ static const CORBA::Long _oc_CORBA_Container_Description[] =
     12, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
     15, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65720000),  // name = dk_ValueMember
     10, ACE_NTOHL (0x646b5f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65000000),  // name = dk_Native
+    13, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x0),  // name = dk_Component
+    8, ACE_NTOHL (0x646b5f48), ACE_NTOHL (0x6f6d6500),  // name = dk_Home
+    11, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72790000),  // name = dk_Factory
+    10, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72000000),  // name = dk_Finder
+    14, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79000000),  // name = dk_PrimaryKey
+    9, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x0),  // name = dk_Emits
+    13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x0),  // name = dk_Publishes
+    12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657300),  // name = dk_Consumes
+    12, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657300),  // name = dk_Provides
+    8, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x73657300),  // name = dk_Uses
 
   6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
   CORBA::tk_any,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_Container_Description (CORBA::tk_struct, sizeof (_oc_CORBA_Container_Description), (char *) &_oc_CORBA_Container_Description, 0, sizeof (CORBA_Container::Description));
-CORBA::TypeCode_ptr CORBA_Container::_tc_Description = &_tc_TAO_tc_CORBA_Container_Description;
+static CORBA::TypeCode _tc_TAO_tc_IR_Container_Description (CORBA::tk_struct, sizeof (_oc_IR_Container_Description), (char *) &_oc_IR_Container_Description, 0, sizeof (IR::Container::Description));
+CORBA::TypeCode_ptr IR::Container::_tc_Description = &_tc_TAO_tc_IR_Container_Description;
 
+void IR::Container::Description::_tao_any_destructor (void *x)
+{
+  Description *tmp = ACE_static_cast (Description*,x);
+  delete tmp;
+}
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CS_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_CONTAINER_DESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_CONTAINER_DESCRIPTIONSEQ_CS_
 
   void
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_Container::Description* tmp = 0;
-    tmp = CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (length);
-
+    IR::Container::Description* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_Container::Description *old = ACE_reinterpret_cast (CORBA_Container::Description *,this->buffer_);
-
+      IR::Container::Description *old = ACE_reinterpret_cast (IR::Container::Description *,this->buffer_);
+      
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-
+      
       if (this->release_)
-        CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (old);
-
+        _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (old);
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_deallocate_buffer (void)
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-
-    CORBA_Container::Description *tmp = ACE_reinterpret_cast (CORBA_Container::Description *,this->buffer_);
-
-    CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
+    
+    IR::Container::Description *tmp = ACE_reinterpret_cast (IR::Container::Description *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (tmp);
     this->buffer_ = 0;
-  }
-
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (void) // Dtor.
+  } 
+  
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::~_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-
-
+  
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ_CS_)
-#define _CORBA_CONTAINER_DESCRIPTIONSEQ_CS_
+#if !defined (_IR_CONTAINER_DESCRIPTIONSEQ_CS_)
+#define _IR_CONTAINER_DESCRIPTIONSEQ_CS_
 
 // *************************************************************
-// CORBA_Container::DescriptionSeq
+// IR::Container::DescriptionSeq
 // *************************************************************
 
-CORBA_Container::DescriptionSeq::DescriptionSeq (void)
+IR::Container::DescriptionSeq::DescriptionSeq (void)
 {}
-CORBA_Container::DescriptionSeq::DescriptionSeq (CORBA::ULong max) // uses max size
-  :
+IR::Container::DescriptionSeq::DescriptionSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq
+  _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_Container::Description>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::Container::Description>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_Container::DescriptionSeq::DescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA_Container::Description *buffer, CORBA::Boolean release)
-  :
+IR::Container::DescriptionSeq::DescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR::Container::Description *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq
+  _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_Container::Description>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::Container::Description>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_Container::DescriptionSeq::DescriptionSeq (const DescriptionSeq &seq) // copy ctor
-  :
+IR::Container::DescriptionSeq::DescriptionSeq (const DescriptionSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq
+  _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_Container::Description>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::Container::Description>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_Container::DescriptionSeq::~DescriptionSeq (void) // dtor
+IR::Container::DescriptionSeq::~DescriptionSeq (void) // dtor
 {}
+void IR::Container::DescriptionSeq::_tao_any_destructor (void *x)
+{
+  DescriptionSeq *tmp = ACE_static_cast (DescriptionSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_Container_DescriptionSeq[] =
+static const CORBA::Long _oc_IR_Container_DescriptionSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  47, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e65722f), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/Container/DescriptionSeq:1.0
+  44, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6572), ACE_NTOHL (0x2f446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/Container/DescriptionSeq:1.0
   15, ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = DescriptionSeq
   CORBA::tk_sequence, // typecode kind
-  684, // encapsulation length
+  844, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
-    668, // encapsulation length
+    828, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      44, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e65722f), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Container/Description:1.0
+      41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6572), ACE_NTOHL (0x2f446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Container/Description:1.0
       12, ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = Description
       3, // member count
       17, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x645f6f62), ACE_NTOHL (0x6a656374), ACE_NTOHL (0x0),  // name = contained_object
       CORBA::tk_objref, // typecode kind
       56, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e65643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Contained:1.0
+        29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6564), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Contained:1.0
         10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x64000000),  // name = Contained
 
       5, ACE_NTOHL (0x6b696e64), ACE_NTOHL (0x0),  // name = kind
       CORBA::tk_enum, // typecode kind
-      472, // encapsulation length
+      632, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4465), ACE_NTOHL (0x66696e69), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4b696e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/DefinitionKind:1.0
+        34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f44), ACE_NTOHL (0x6566696e), ACE_NTOHL (0x6974696f), ACE_NTOHL (0x6e4b696e), ACE_NTOHL (0x643a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/DefinitionKind:1.0
         15, ACE_NTOHL (0x44656669), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x6f6e4b69), ACE_NTOHL (0x6e640000),  // name = DefinitionKind
-        24, // member count
+        34, // member count
         8, ACE_NTOHL (0x646b5f6e), ACE_NTOHL (0x6f6e6500),  // name = dk_none
         7, ACE_NTOHL (0x646b5f61), ACE_NTOHL (0x6c6c0000),  // name = dk_all
         13, ACE_NTOHL (0x646b5f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x0),  // name = dk_Attribute
@@ -2561,6 +5448,16 @@ static const CORBA::Long _oc_CORBA_Container_DescriptionSeq[] =
         12, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7800),  // name = dk_ValueBox
         15, ACE_NTOHL (0x646b5f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65720000),  // name = dk_ValueMember
         10, ACE_NTOHL (0x646b5f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65000000),  // name = dk_Native
+        13, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x0),  // name = dk_Component
+        8, ACE_NTOHL (0x646b5f48), ACE_NTOHL (0x6f6d6500),  // name = dk_Home
+        11, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72790000),  // name = dk_Factory
+        10, ACE_NTOHL (0x646b5f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72000000),  // name = dk_Finder
+        14, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79000000),  // name = dk_PrimaryKey
+        9, ACE_NTOHL (0x646b5f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x0),  // name = dk_Emits
+        13, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x0),  // name = dk_Publishes
+        12, ACE_NTOHL (0x646b5f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657300),  // name = dk_Consumes
+        12, ACE_NTOHL (0x646b5f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657300),  // name = dk_Provides
+        8, ACE_NTOHL (0x646b5f55), ACE_NTOHL (0x73657300),  // name = dk_Uses
 
       6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
       CORBA::tk_any,
@@ -2569,29 +5466,30 @@ static const CORBA::Long _oc_CORBA_Container_DescriptionSeq[] =
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_Container_DescriptionSeq (CORBA::tk_alias, sizeof (_oc_CORBA_Container_DescriptionSeq), (char *) &_oc_CORBA_Container_DescriptionSeq, 0, sizeof (CORBA_Container::DescriptionSeq));
-CORBA::TypeCode_ptr CORBA_Container::_tc_DescriptionSeq = &_tc_TAO_tc_CORBA_Container_DescriptionSeq;
+static CORBA::TypeCode _tc_TAO_tc_IR_Container_DescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_Container_DescriptionSeq), (char *) &_oc_IR_Container_DescriptionSeq, 0, sizeof (IR::Container::DescriptionSeq));
+CORBA::TypeCode_ptr IR::Container::_tc_DescriptionSeq = &_tc_TAO_tc_IR_Container_DescriptionSeq;
 
-CORBA_Container::DescriptionSeq * CORBA_Container::describe_contents (
-   CORBA::DefinitionKind limit_type,
+IR::Container::DescriptionSeq * IR::Container::describe_contents (
+    IR::DefinitionKind limit_type,
     CORBA::Boolean exclude_inherited,
     CORBA::Long max_returned_objs,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_Container::DescriptionSeq* _tao_retval = 0;
-
-
+  
+  IR::Container::DescriptionSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_Container::DescriptionSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::Container::DescriptionSeq, _tao_retval);
+  IR::Container::DescriptionSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "describe_contents",
@@ -2599,69 +5497,128 @@ CORBA_Container::DescriptionSeq * CORBA_Container::describe_contents (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << limit_type) &&
-          (_tao_out << CORBA_Any::from_boolean (exclude_inherited)) &&
-          (_tao_out << max_returned_objs)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "describe_contents",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << limit_type) &&
+              (_tao_out << CORBA::Any::from_boolean (exclude_inherited)) &&
+              (_tao_out << max_returned_objs)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "describe_contents",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "describe_contents",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_ModuleDef_ptr CORBA_Container::create_module (
+IR::ModuleDef_ptr IR::Container::create_module (
     const char * id,
     const char * name,
     const char * version,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_ModuleDef_ptr _tao_retval = CORBA_ModuleDef::_nil ();
-
-
+  
+  IR::ModuleDef_ptr _tao_retval = IR::ModuleDef::_nil ();
+  IR::ModuleDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_module",
@@ -2669,71 +5626,130 @@ CORBA_ModuleDef_ptr CORBA_Container::create_module (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_module",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_module",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_module",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_ConstantDef_ptr CORBA_Container::create_constant (
+IR::ConstantDef_ptr IR::Container::create_constant (
     const char * id,
     const char * name,
     const char * version,
-    CORBA_IDLType_ptr type,
-    const CORBA_Any & value,
-    CORBA_Environment &ACE_TRY_ENV
+    IR::IDLType_ptr type,
+    const CORBA::Any & value,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_ConstantDef_ptr _tao_retval = CORBA_ConstantDef::_nil ();
-
-
+  
+  IR::ConstantDef_ptr _tao_retval = IR::ConstantDef::_nil ();
+  IR::ConstantDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_constant",
@@ -2741,72 +5757,131 @@ CORBA_ConstantDef_ptr CORBA_Container::create_constant (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << type) &&
-          (_tao_out << value)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_constant",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << type) &&
+              (_tao_out << value)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_constant",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_constant",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_StructDef_ptr CORBA_Container::create_struct (
+IR::StructDef_ptr IR::Container::create_struct (
     const char * id,
     const char * name,
     const char * version,
-    const CORBA_StructMemberSeq & members,
-    CORBA_Environment &ACE_TRY_ENV
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_StructDef_ptr _tao_retval = CORBA_StructDef::_nil ();
-
-
+  
+  IR::StructDef_ptr _tao_retval = IR::StructDef::_nil ();
+  IR::StructDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_struct",
@@ -2814,72 +5889,131 @@ CORBA_StructDef_ptr CORBA_Container::create_struct (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << members)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_struct",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_struct",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_struct",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_UnionDef_ptr CORBA_Container::create_union (
+IR::UnionDef_ptr IR::Container::create_union (
     const char * id,
     const char * name,
     const char * version,
-    CORBA_IDLType_ptr discriminator_type,
-    const CORBA_UnionMemberSeq & members,
-    CORBA_Environment &ACE_TRY_ENV
+    IR::IDLType_ptr discriminator_type,
+    const IR::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_UnionDef_ptr _tao_retval = CORBA_UnionDef::_nil ();
-
-
+  
+  IR::UnionDef_ptr _tao_retval = IR::UnionDef::_nil ();
+  IR::UnionDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_union",
@@ -2887,72 +6021,131 @@ CORBA_UnionDef_ptr CORBA_Container::create_union (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << discriminator_type) &&
-          (_tao_out << members)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_union",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << discriminator_type) &&
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_union",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_union",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_EnumDef_ptr CORBA_Container::create_enum (
+IR::EnumDef_ptr IR::Container::create_enum (
     const char * id,
     const char * name,
     const char * version,
-    const CORBA_EnumMemberSeq & members,
-    CORBA_Environment &ACE_TRY_ENV
+    const IR::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_EnumDef_ptr _tao_retval = CORBA_EnumDef::_nil ();
-
-
+  
+  IR::EnumDef_ptr _tao_retval = IR::EnumDef::_nil ();
+  IR::EnumDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_enum",
@@ -2960,71 +6153,130 @@ CORBA_EnumDef_ptr CORBA_Container::create_enum (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << members)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_enum",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_enum",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_enum",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_AliasDef_ptr CORBA_Container::create_alias (
+IR::AliasDef_ptr IR::Container::create_alias (
     const char * id,
     const char * name,
     const char * version,
-    CORBA_IDLType_ptr original_type,
-    CORBA_Environment &ACE_TRY_ENV
+    IR::IDLType_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_AliasDef_ptr _tao_retval = CORBA_AliasDef::_nil ();
-
-
+  
+  IR::AliasDef_ptr _tao_retval = IR::AliasDef::_nil ();
+  IR::AliasDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_alias",
@@ -3032,71 +6284,131 @@ CORBA_AliasDef_ptr CORBA_Container::create_alias (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << original_type)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_alias",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << original_type)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_alias",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_alias",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_InterfaceDef_ptr CORBA_Container::create_interface (
+IR::InterfaceDef_ptr IR::Container::create_interface (
     const char * id,
     const char * name,
     const char * version,
-    const CORBA_InterfaceDefSeq & base_interfaces,
-    CORBA_Environment &ACE_TRY_ENV
+    const IR::InterfaceDefSeq & base_interfaces,
+    CORBA::Boolean is_abstract,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_InterfaceDef_ptr _tao_retval = CORBA_InterfaceDef::_nil ();
-
-
+  
+  IR::InterfaceDef_ptr _tao_retval = IR::InterfaceDef::_nil ();
+  IR::InterfaceDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_interface",
@@ -3104,77 +6416,137 @@ CORBA_InterfaceDef_ptr CORBA_Container::create_interface (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << base_interfaces)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_interface",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << base_interfaces) &&
+              (_tao_out << CORBA::Any::from_boolean (is_abstract))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_interface",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_interface",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_ValueDef_ptr CORBA_Container::create_value (
+IR::ValueDef_ptr IR::Container::create_value (
     const char * id,
     const char * name,
     const char * version,
     CORBA::Boolean is_custom,
     CORBA::Boolean is_abstract,
-    CORBA_ValueDef_ptr base_value,
+    IR::ValueDef_ptr base_value,
     CORBA::Boolean is_truncatable,
-    const CORBA_ValueDefSeq & abstract_base_values,
-    CORBA_InterfaceDef_ptr supported_interface,
-    const CORBA_InitializerSeq & initializers,
-    CORBA_Environment &ACE_TRY_ENV
+    const IR::ValueDefSeq & abstract_base_values,
+    const IR::InterfaceDefSeq & supported_interfaces,
+    const IR::InitializerSeq & initializers,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_ValueDef_ptr _tao_retval = CORBA_ValueDef::_nil ();
-
-
+  
+  IR::ValueDef_ptr _tao_retval = IR::ValueDef::_nil ();
+  IR::ValueDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_value",
@@ -3182,338 +6554,1128 @@ CORBA_ValueDef_ptr CORBA_Container::create_value (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << CORBA::Any::from_boolean (is_custom)) &&
+              (_tao_out << CORBA::Any::from_boolean (is_abstract)) &&
+              (_tao_out << base_value) &&
+              (_tao_out << CORBA::Any::from_boolean (is_truncatable)) &&
+              (_tao_out << abstract_base_values) &&
+              (_tao_out << supported_interfaces) &&
+              (_tao_out << initializers)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_value",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    CORBA::Short flag = 131;
+IR::ValueBoxDef_ptr IR::Container::create_value_box (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ValueBoxDef_ptr _tao_retval = IR::ValueBoxDef::_nil ();
+  IR::ValueBoxDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_value_box",
+      16,
+      istub->orb_core ()
+    );
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << CORBA_Any::from_boolean (is_custom)) &&
-          (_tao_out << CORBA_Any::from_boolean (is_abstract)) &&
-          (_tao_out << base_value) &&
-          (_tao_out << CORBA_Any::from_boolean (is_truncatable)) &&
-          (_tao_out << abstract_base_values) &&
-          (_tao_out << supported_interface) &&
-          (_tao_out << initializers)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value_box",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << original_type_def)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value_box",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_value_box",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_ValueBoxDef_ptr CORBA_Container::create_value_box (
+IR::ExceptionDef_ptr IR::Container::create_exception (
     const char * id,
     const char * name,
     const char * version,
-    CORBA_IDLType_ptr original_type_def,
-    CORBA_Environment &ACE_TRY_ENV
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+  IR::ExceptionDef_ptr _tao_retval = IR::ExceptionDef::_nil ();
+  IR::ExceptionDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_exception",
+      16,
+      istub->orb_core ()
+    );
 
-  CORBA_ValueBoxDef_ptr _tao_retval = CORBA_ValueBoxDef::_nil ();
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_exception",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_exception",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_exception",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+IR::NativeDef_ptr IR::Container::create_native (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::NativeDef_ptr _tao_retval = IR::NativeDef::_nil ();
+  IR::NativeDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "create_value_box",
-      16,
+      "create_native",
+      13,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_native",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_native",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_native",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << original_type_def)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+CORBA::Boolean IR::Container::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+const char* IR::Container::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/Container:1.0";
+}
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+IR::TAO_IR_Container_Default_Proxy_Factory::TAO_IR_Container_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+      TAO_IR_Container_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_Container_Default_Proxy_Factory::~TAO_IR_Container_Default_Proxy_Factory (void)
+{
+}
+
+IR::Container_ptr
+IR::TAO_IR_Container_Default_Proxy_Factory::create_proxy (
+    ::IR::Container_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
 
+IR::TAO_IR_Container_Proxy_Factory_Adapter::TAO_IR_Container_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_Container_Proxy_Factory_Adapter::~TAO_IR_Container_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_Container_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_Container_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_Container_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
     }
-    break;
+return 0;
+}
+
+IR::Container_ptr
+IR::TAO_IR_Container_Proxy_Factory_Adapter::create_proxy (
+    ::IR::Container_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_Container_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_Container_Smart_Proxy_Base::TAO_IR_Container_Smart_Proxy_Base (::IR::Container_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_Container_Smart_Proxy_Base::~TAO_IR_Container_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_Container_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::Contained_ptr IR::TAO_IR_Container_Smart_Proxy_Base::lookup  (
+    const char * search_name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->lookup (
+      search_name,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ContainedSeq * IR::TAO_IR_Container_Smart_Proxy_Base::contents  (
+    IR::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->contents (
+      limit_type,
+      exclude_inherited,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ContainedSeq * IR::TAO_IR_Container_Smart_Proxy_Base::lookup_name  (
+    const char * search_name,
+    CORBA::Long levels_to_search,
+    IR::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->lookup_name (
+      search_name,
+      levels_to_search,
+      limit_type,
+      exclude_inherited,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::Container::DescriptionSeq * IR::TAO_IR_Container_Smart_Proxy_Base::describe_contents  (
+    IR::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Long max_returned_objs,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->describe_contents (
+      limit_type,
+      exclude_inherited,
+      max_returned_objs,
+      ACE_TRY_ENV
+    );
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
 }
 
-CORBA_ExceptionDef_ptr CORBA_Container::create_exception (
+IR::ModuleDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_module  (
     const char * id,
     const char * name,
     const char * version,
-    const CORBA_StructMemberSeq & members,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  return this->base_proxy_->create_module (
+      id,
+      name,
+      version,
+      ACE_TRY_ENV
+    );
 
-  CORBA_ExceptionDef_ptr _tao_retval = CORBA_ExceptionDef::_nil ();
+}
 
+IR::ConstantDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_constant  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr type,
+    const CORBA::Any & value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_constant (
+      id,
+      name,
+      version,
+      type,
+      value,
+      ACE_TRY_ENV
+    );
 
-  TAO_Stub *istub = this->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+}
 
+IR::StructDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_struct  (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_struct (
+      id,
+      name,
+      version,
+      members,
+      ACE_TRY_ENV
+    );
 
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_exception",
-      16,
-      istub->orb_core ()
+}
+
+IR::UnionDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_union  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr discriminator_type,
+    const IR::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_union (
+      id,
+      name,
+      version,
+      discriminator_type,
+      members,
+      ACE_TRY_ENV
     );
 
+}
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+IR::EnumDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_enum  (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_enum (
+      id,
+      name,
+      version,
+      members,
+      ACE_TRY_ENV
+    );
 
-    CORBA::Short flag = 131;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+IR::AliasDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_alias  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_alias (
+      id,
+      name,
+      version,
+      original_type,
+      ACE_TRY_ENV
+    );
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << members)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+IR::InterfaceDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_interface  (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::InterfaceDefSeq & base_interfaces,
+    CORBA::Boolean is_abstract,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_interface (
+      id,
+      name,
+      version,
+      base_interfaces,
+      is_abstract,
+      ACE_TRY_ENV
+    );
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+}
 
-    }
-    break;
+IR::ValueDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_value  (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Boolean is_custom,
+    CORBA::Boolean is_abstract,
+    IR::ValueDef_ptr base_value,
+    CORBA::Boolean is_truncatable,
+    const IR::ValueDefSeq & abstract_base_values,
+    const IR::InterfaceDefSeq & supported_interfaces,
+    const IR::InitializerSeq & initializers,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_value (
+      id,
+      name,
+      version,
+      is_custom,
+      is_abstract,
+      base_value,
+      is_truncatable,
+      abstract_base_values,
+      supported_interfaces,
+      initializers,
+      ACE_TRY_ENV
+    );
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
 }
 
-CORBA::Boolean CORBA_Container::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+IR::ValueBoxDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_value_box  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+  return this->base_proxy_->create_value_box (
+      id,
+      name,
+      version,
+      original_type_def,
+      ACE_TRY_ENV
+    );
+
 }
 
-const char* CORBA_Container::_interface_repository_id (void) const
+IR::ExceptionDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_exception  (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  return "IDL:omg.org/CORBA/Container:1.0";
+  return this->base_proxy_->create_exception (
+      id,
+      name,
+      version,
+      members,
+      ACE_TRY_ENV
+    );
+
 }
 
-static const CORBA::Long _oc_CORBA_Container[] =
+IR::NativeDef_ptr IR::TAO_IR_Container_Smart_Proxy_Base::create_native  (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_native (
+      id,
+      name,
+      version,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_Container_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_Container_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_Container[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746169), ACE_NTOHL (0x6e65723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/Container:1.0
+  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7461), ACE_NTOHL (0x696e6572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/Container:1.0
   10, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x61696e65), ACE_NTOHL (0x72000000),  // name = Container
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_Container (CORBA::tk_objref, sizeof (_oc_CORBA_Container), (char *) &_oc_CORBA_Container, 0, sizeof (CORBA_Container));
+static CORBA::TypeCode _tc_TAO_tc_IR_Container (CORBA::tk_objref, sizeof (_oc_IR_Container), (char *) &_oc_IR_Container, 0, sizeof (IR::Container));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Container, &_tc_TAO_tc_CORBA_Container)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Container, &_tc_TAO_tc_IR_Container)
 TAO_NAMESPACE_END
-CORBA_IDLType_ptr CORBA_IDLType::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::IDLType::_tao_any_destructor (void *x)
+{
+  IDLType *tmp = ACE_static_cast (IDLType*,x);
+  CORBA::release (tmp);
+}
+
+IR::IDLType_ptr IR::IDLType::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_IDLType::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/IDLType:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_IDLType::_nil ());
+    return IDLType::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/IDLType:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (IDLType::_nil ());
   if (is_a == 0)
-    return CORBA_IDLType::_nil ();
-  return CORBA_IDLType::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return IDLType::_nil ();
+  return IDLType::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_IDLType_ptr CORBA_IDLType::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::IDLType_ptr IR::IDLType::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_IDLType::_nil ();
+    return IDLType::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  IDLType_ptr default_proxy = IDLType::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_IDLType_Stub_Factory_function_pointer != 0)
     {
-      CORBA_IDLType_ptr retv = _TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_IDLType_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_IDLType_ptr retval = CORBA_IDLType::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_IDLType (stub),
-                  CORBA_IDLType::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, IDLType (stub), IDLType::_nil ());
+  return TAO_IR_IDLType_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_IDLType_ptr
-CORBA_IDLType::_duplicate (CORBA_IDLType_ptr obj)
+IR::IDLType_ptr 
+IR::IDLType::_duplicate (IDLType_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::TypeCode_ptr CORBA_IDLType::type (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::TypeCode_ptr IR::IDLType::type (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::TypeCode_ptr _tao_retval = 0;
-
-
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""type",
+      "_get_type",
       9,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA::Boolean CORBA_IDLType::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::IDLType::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -3521,28 +7683,149 @@ CORBA::Boolean CORBA_IDLType::_is_a (const CORBA::Char *value, CORBA_Environment
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_IDLType::_interface_repository_id (void) const
+const char* IR::IDLType::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/IDLType:1.0";
+}
+
+IR::TAO_IR_IDLType_Default_Proxy_Factory::TAO_IR_IDLType_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_IDLType_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_IDLType_Default_Proxy_Factory::~TAO_IR_IDLType_Default_Proxy_Factory (void)
+{
+}
+
+IR::IDLType_ptr
+IR::TAO_IR_IDLType_Default_Proxy_Factory::create_proxy (
+    ::IR::IDLType_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_IDLType_Proxy_Factory_Adapter::TAO_IR_IDLType_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_IDLType_Proxy_Factory_Adapter::~TAO_IR_IDLType_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_IDLType_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_IDLType_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
 {
-  return "IDL:omg.org/CORBA/IDLType:1.0";
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
 }
 
-static const CORBA::Long _oc_CORBA_IDLType[] =
+int
+IR::TAO_IR_IDLType_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::IDLType_ptr
+IR::TAO_IR_IDLType_Proxy_Factory_Adapter::create_proxy (
+    ::IR::IDLType_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_IDLType_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_IDLType_Smart_Proxy_Base::TAO_IR_IDLType_Smart_Proxy_Base (::IR::IDLType_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_IDLType_Smart_Proxy_Base::~TAO_IR_IDLType_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_IDLType_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::TypeCode_ptr IR::TAO_IR_IDLType_Smart_Proxy_Base::type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->type (
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_IDLType_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_IDLType_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_IDLType[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+  27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
   8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_IDLType (CORBA::tk_objref, sizeof (_oc_CORBA_IDLType), (char *) &_oc_CORBA_IDLType, 0, sizeof (CORBA_IDLType));
+static CORBA::TypeCode _tc_TAO_tc_IR_IDLType (CORBA::tk_objref, sizeof (_oc_IR_IDLType), (char *) &_oc_IR_IDLType, 0, sizeof (IR::IDLType));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IDLType, &_tc_TAO_tc_CORBA_IDLType)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_IDLType, &_tc_TAO_tc_IR_IDLType)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_PrimitiveKind[] =
+static const CORBA::Long _oc_IR_PrimitiveKind[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5072), ACE_NTOHL (0x696d6974), ACE_NTOHL (0x6976654b), ACE_NTOHL (0x696e643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/PrimitiveKind:1.0
+  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d69), ACE_NTOHL (0x74697665), ACE_NTOHL (0x4b696e64), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimitiveKind:1.0
   14, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x69746976), ACE_NTOHL (0x654b696e), ACE_NTOHL (0x64000000),  // name = PrimitiveKind
-  21, // member count
+  22, // member count
   8, ACE_NTOHL (0x706b5f6e), ACE_NTOHL (0x756c6c00),  // name = pk_null
   8, ACE_NTOHL (0x706b5f76), ACE_NTOHL (0x6f696400),  // name = pk_void
   9, ACE_NTOHL (0x706b5f73), ACE_NTOHL (0x686f7274), ACE_NTOHL (0x0),  // name = pk_short
@@ -3564,76 +7847,79 @@ static const CORBA::Long _oc_CORBA_PrimitiveKind[] =
   14, ACE_NTOHL (0x706b5f6c), ACE_NTOHL (0x6f6e6764), ACE_NTOHL (0x6f75626c), ACE_NTOHL (0x65000000),  // name = pk_longdouble
   9, ACE_NTOHL (0x706b5f77), ACE_NTOHL (0x63686172), ACE_NTOHL (0x0),  // name = pk_wchar
   11, ACE_NTOHL (0x706b5f77), ACE_NTOHL (0x73747269), ACE_NTOHL (0x6e670000),  // name = pk_wstring
+  14, ACE_NTOHL (0x706b5f76), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x5f626173), ACE_NTOHL (0x65000000),  // name = pk_value_base
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_PrimitiveKind (CORBA::tk_enum, sizeof (_oc_CORBA_PrimitiveKind), (char *) &_oc_CORBA_PrimitiveKind, 0, sizeof (CORBA::PrimitiveKind));
+static CORBA::TypeCode _tc_TAO_tc_IR_PrimitiveKind (CORBA::tk_enum, sizeof (_oc_IR_PrimitiveKind), (char *) &_oc_IR_PrimitiveKind, 0, sizeof (IR::PrimitiveKind));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimitiveKind, &_tc_TAO_tc_CORBA_PrimitiveKind)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimitiveKind, &_tc_TAO_tc_IR_PrimitiveKind)
 TAO_NAMESPACE_END
-CORBA_Repository_ptr CORBA_Repository::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::Repository::_tao_any_destructor (void *x)
+{
+  Repository *tmp = ACE_static_cast (Repository*,x);
+  CORBA::release (tmp);
+}
+
+IR::Repository_ptr IR::Repository::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_Repository::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/Repository:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_Repository::_nil ());
+    return Repository::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/Repository:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (Repository::_nil ());
   if (is_a == 0)
-    return CORBA_Repository::_nil ();
-  return CORBA_Repository::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return Repository::_nil ();
+  return Repository::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_Repository_ptr CORBA_Repository::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::Repository_ptr IR::Repository::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_Repository::_nil ();
+    return Repository::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  Repository_ptr default_proxy = Repository::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_Repository_Stub_Factory_function_pointer != 0)
     {
-      CORBA_Repository_ptr retv = _TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_Repository_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_Repository_ptr retval = CORBA_Repository::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_Repository (stub),
-                  CORBA_Repository::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, Repository (stub), Repository::_nil ());
+  return TAO_IR_Repository_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_Repository_ptr
-CORBA_Repository::_duplicate (CORBA_Repository_ptr obj)
+IR::Repository_ptr 
+IR::Repository::_duplicate (Repository_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA_Contained_ptr CORBA_Repository::lookup_id (
+IR::Contained_ptr IR::Repository::lookup_id (
     const char * search_id,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_Contained_ptr _tao_retval = CORBA_Contained::_nil ();
-
-
+  
+  IR::Contained_ptr _tao_retval = IR::Contained::_nil ();
+  IR::Contained_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "lookup_id",
@@ -3641,65 +7927,249 @@ CORBA_Contained_ptr CORBA_Repository::lookup_id (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "lookup_id",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << search_id)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "lookup_id",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "lookup_id",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+CORBA::TypeCode_ptr IR::Repository::get_canonical_typecode (
+    CORBA::TypeCode_ptr tc,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << search_id)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "get_canonical_typecode",
+      22,
+      istub->orb_core ()
+    );
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "get_canonical_typecode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << tc)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "get_canonical_typecode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "get_canonical_typecode",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_PrimitiveDef_ptr CORBA_Repository::get_primitive (
-    CORBA::PrimitiveKind kind,
-    CORBA_Environment &ACE_TRY_ENV
+IR::PrimitiveDef_ptr IR::Repository::get_primitive (
+    IR::PrimitiveKind kind,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_PrimitiveDef_ptr _tao_retval = CORBA_PrimitiveDef::_nil ();
-
-
+  
+  IR::PrimitiveDef_ptr _tao_retval = IR::PrimitiveDef::_nil ();
+  IR::PrimitiveDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "get_primitive",
@@ -3707,65 +8177,124 @@ CORBA_PrimitiveDef_ptr CORBA_Repository::get_primitive (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << kind)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "get_primitive",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << kind)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "get_primitive",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "get_primitive",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_StringDef_ptr CORBA_Repository::create_string (
+IR::StringDef_ptr IR::Repository::create_string (
     CORBA::ULong bound,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_StringDef_ptr _tao_retval = CORBA_StringDef::_nil ();
-
-
+  
+  IR::StringDef_ptr _tao_retval = IR::StringDef::_nil ();
+  IR::StringDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_string",
@@ -3773,65 +8302,124 @@ CORBA_StringDef_ptr CORBA_Repository::create_string (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << bound)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_string",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << bound)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_string",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_string",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_WstringDef_ptr CORBA_Repository::create_wstring (
+IR::WstringDef_ptr IR::Repository::create_wstring (
     CORBA::ULong bound,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_WstringDef_ptr _tao_retval = CORBA_WstringDef::_nil ();
-
-
+  
+  IR::WstringDef_ptr _tao_retval = IR::WstringDef::_nil ();
+  IR::WstringDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "create_wstring",
@@ -3839,257 +8427,1071 @@ CORBA_WstringDef_ptr CORBA_Repository::create_wstring (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_wstring",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << bound)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_wstring",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_wstring",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    CORBA::Short flag = 131;
+IR::SequenceDef_ptr IR::Repository::create_sequence (
+    CORBA::ULong bound,
+    IR::IDLType_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::SequenceDef_ptr _tao_retval = IR::SequenceDef::_nil ();
+  IR::SequenceDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_sequence",
+      15,
+      istub->orb_core ()
+    );
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << bound)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_sequence",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << bound) &&
+              (_tao_out << element_type)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_sequence",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_sequence",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_SequenceDef_ptr CORBA_Repository::create_sequence (
-    CORBA::ULong bound,
-    CORBA_IDLType_ptr element_type,
-    CORBA_Environment &ACE_TRY_ENV
+IR::ArrayDef_ptr IR::Repository::create_array (
+    CORBA::ULong length,
+    IR::IDLType_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+  IR::ArrayDef_ptr _tao_retval = IR::ArrayDef::_nil ();
+  IR::ArrayDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-  CORBA_SequenceDef_ptr _tao_retval = CORBA_SequenceDef::_nil ();
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_array",
+      12,
+      istub->orb_core ()
+    );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_array",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << length) &&
+              (_tao_out << element_type)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_array",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_array",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
+IR::FixedDef_ptr IR::Repository::create_fixed (
+    CORBA::UShort digits,
+    CORBA::Short scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::FixedDef_ptr _tao_retval = IR::FixedDef::_nil ();
+  IR::FixedDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "create_sequence",
-      15,
+      "create_fixed",
+      12,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_fixed",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << digits) &&
+              (_tao_out << scale)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_fixed",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_fixed",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << bound) &&
-          (_tao_out << element_type)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+CORBA::Boolean IR::Repository::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Repository:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+const char* IR::Repository::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/Repository:1.0";
+}
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+IR::TAO_IR_Repository_Default_Proxy_Factory::TAO_IR_Repository_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+      TAO_IR_Repository_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_Repository_Default_Proxy_Factory::~TAO_IR_Repository_Default_Proxy_Factory (void)
+{
+}
 
+IR::Repository_ptr
+IR::TAO_IR_Repository_Default_Proxy_Factory::create_proxy (
+    ::IR::Repository_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_Repository_Proxy_Factory_Adapter::TAO_IR_Repository_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_Repository_Proxy_Factory_Adapter::~TAO_IR_Repository_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_Repository_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_Repository_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_Repository_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
     }
-    break;
+return 0;
+}
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+IR::Repository_ptr
+IR::TAO_IR_Repository_Proxy_Factory_Adapter::create_proxy (
+    ::IR::Repository_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_Repository_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
 }
 
-CORBA_ArrayDef_ptr CORBA_Repository::create_array (
-    CORBA::ULong length,
-    CORBA_IDLType_ptr element_type,
-    CORBA_Environment &ACE_TRY_ENV
+IR::TAO_IR_Repository_Smart_Proxy_Base::TAO_IR_Repository_Smart_Proxy_Base (::IR::Repository_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_Repository_Smart_Proxy_Base::~TAO_IR_Repository_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_Repository_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::Contained_ptr IR::TAO_IR_Repository_Smart_Proxy_Base::lookup_id  (
+    const char * search_id,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  return this->base_proxy_->lookup_id (
+      search_id,
+      ACE_TRY_ENV
+    );
 
-  CORBA_ArrayDef_ptr _tao_retval = CORBA_ArrayDef::_nil ();
-
+}
 
-  TAO_Stub *istub = this->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+CORBA::TypeCode_ptr IR::TAO_IR_Repository_Smart_Proxy_Base::get_canonical_typecode  (
+    CORBA::TypeCode_ptr tc,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->get_canonical_typecode (
+      tc,
+      ACE_TRY_ENV
+    );
 
+}
 
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_array",
-      12,
-      istub->orb_core ()
+IR::PrimitiveDef_ptr IR::TAO_IR_Repository_Smart_Proxy_Base::get_primitive  (
+    IR::PrimitiveKind kind,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->get_primitive (
+      kind,
+      ACE_TRY_ENV
     );
 
+}
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+IR::StringDef_ptr IR::TAO_IR_Repository_Smart_Proxy_Base::create_string  (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_string (
+      bound,
+      ACE_TRY_ENV
+    );
 
-    CORBA::Short flag = 131;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+IR::WstringDef_ptr IR::TAO_IR_Repository_Smart_Proxy_Base::create_wstring  (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_wstring (
+      bound,
+      ACE_TRY_ENV
+    );
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << length) &&
-          (_tao_out << element_type)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+IR::SequenceDef_ptr IR::TAO_IR_Repository_Smart_Proxy_Base::create_sequence  (
+    CORBA::ULong bound,
+    IR::IDLType_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_sequence (
+      bound,
+      element_type,
+      ACE_TRY_ENV
+    );
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+}
 
-    }
-    break;
+IR::ArrayDef_ptr IR::TAO_IR_Repository_Smart_Proxy_Base::create_array  (
+    CORBA::ULong length,
+    IR::IDLType_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_array (
+      length,
+      element_type,
+      ACE_TRY_ENV
+    );
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
 }
 
-CORBA_FixedDef_ptr CORBA_Repository::create_fixed (
+IR::FixedDef_ptr IR::TAO_IR_Repository_Smart_Proxy_Base::create_fixed  (
     CORBA::UShort digits,
     CORBA::Short scale,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  return this->base_proxy_->create_fixed (
+      digits,
+      scale,
+      ACE_TRY_ENV
+    );
+
+}
 
-  CORBA_FixedDef_ptr _tao_retval = CORBA_FixedDef::_nil ();
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_Repository_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_Repository_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
+static const CORBA::Long _oc_IR_Repository[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x793a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Repository:1.0
+  11, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72790000),  // name = Repository
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_Repository (CORBA::tk_objref, sizeof (_oc_IR_Repository), (char *) &_oc_IR_Repository, 0, sizeof (IR::Repository));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Repository, &_tc_TAO_tc_IR_Repository)
+TAO_NAMESPACE_END
+void IR::ComponentRepository::_tao_any_destructor (void *x)
+{
+  ComponentRepository *tmp = ACE_static_cast (ComponentRepository*,x);
+  CORBA::release (tmp);
+}
 
+IR::ComponentRepository_ptr IR::ComponentRepository::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ComponentRepository::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ComponentRepository:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ComponentRepository::_nil ());
+  if (is_a == 0)
+    return ComponentRepository::_nil ();
+  return ComponentRepository::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::ComponentRepository_ptr IR::ComponentRepository::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ComponentRepository::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  ComponentRepository_ptr default_proxy = ComponentRepository::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ComponentRepository_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_ComponentRepository_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ComponentRepository (stub), ComponentRepository::_nil ());
+  return TAO_IR_ComponentRepository_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::ComponentRepository_ptr 
+IR::ComponentRepository::_duplicate (ComponentRepository_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+IR::ComponentDef_ptr IR::ComponentRepository::create_component (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ComponentDef_ptr base_component,
+    const IR::InterfaceDefSeq & supports_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ComponentDef_ptr _tao_retval = IR::ComponentDef::_nil ();
+  IR::ComponentDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "create_fixed",
-      12,
+      "create_component",
+      16,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_component",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << base_component) &&
+              (_tao_out << supports_interfaces)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_component",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_component",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+IR::HomeDef_ptr IR::ComponentRepository::create_home (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::HomeDef_ptr base_home,
+    IR::ComponentDef_ptr managed_component,
+    IR::ValueDef_ptr primary_key,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::HomeDef_ptr _tao_retval = IR::HomeDef::_nil ();
+  IR::HomeDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << digits) &&
-          (_tao_out << scale)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_home",
+      11,
+      istub->orb_core ()
+    );
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_home",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << base_home) &&
+              (_tao_out << managed_component) &&
+              (_tao_out << primary_key)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_home",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_home",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA::Boolean CORBA_Repository::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::ComponentRepository::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Repository:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ComponentRepository:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Repository:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -4097,75 +9499,232 @@ CORBA::Boolean CORBA_Repository::_is_a (const CORBA::Char *value, CORBA_Environm
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_Repository::_interface_repository_id (void) const
+const char* IR::ComponentRepository::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ComponentRepository:1.0";
+}
+
+IR::TAO_IR_ComponentRepository_Default_Proxy_Factory::TAO_IR_ComponentRepository_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_ComponentRepository_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ComponentRepository_Default_Proxy_Factory::~TAO_IR_ComponentRepository_Default_Proxy_Factory (void)
+{
+}
+
+IR::ComponentRepository_ptr
+IR::TAO_IR_ComponentRepository_Default_Proxy_Factory::create_proxy (
+    ::IR::ComponentRepository_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ComponentRepository_Proxy_Factory_Adapter::TAO_IR_ComponentRepository_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ComponentRepository_Proxy_Factory_Adapter::~TAO_IR_ComponentRepository_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ComponentRepository_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ComponentRepository_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ComponentRepository_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::ComponentRepository_ptr
+IR::TAO_IR_ComponentRepository_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ComponentRepository_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ComponentRepository_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_ComponentRepository_Smart_Proxy_Base::TAO_IR_ComponentRepository_Smart_Proxy_Base (::IR::ComponentRepository_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ComponentRepository_Smart_Proxy_Base::~TAO_IR_ComponentRepository_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ComponentRepository_Smart_Proxy_Base::_stubobj (void) const
 {
-  return "IDL:omg.org/CORBA/Repository:1.0";
+  return this->base_proxy_->_stubobj ();
 }
 
-static const CORBA::Long _oc_CORBA_Repository[] =
+IR::ComponentDef_ptr IR::TAO_IR_ComponentRepository_Smart_Proxy_Base::create_component  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ComponentDef_ptr base_component,
+    const IR::InterfaceDefSeq & supports_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_component (
+      id,
+      name,
+      version,
+      base_component,
+      supports_interfaces,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::HomeDef_ptr IR::TAO_IR_ComponentRepository_Smart_Proxy_Base::create_home  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::HomeDef_ptr base_home,
+    IR::ComponentDef_ptr managed_component,
+    IR::ValueDef_ptr primary_key,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_home (
+      id,
+      name,
+      version,
+      base_home,
+      managed_component,
+      primary_key,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ComponentRepository_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ComponentRepository_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ComponentRepository[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Repository:1.0
-  11, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72790000),  // name = Repository
+  39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72793a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ComponentRepository:1.0
+  20, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74526570), ACE_NTOHL (0x6f736974), ACE_NTOHL (0x6f727900),  // name = ComponentRepository
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_Repository (CORBA::tk_objref, sizeof (_oc_CORBA_Repository), (char *) &_oc_CORBA_Repository, 0, sizeof (CORBA_Repository));
+static CORBA::TypeCode _tc_TAO_tc_IR_ComponentRepository (CORBA::tk_objref, sizeof (_oc_IR_ComponentRepository), (char *) &_oc_IR_ComponentRepository, 0, sizeof (IR::ComponentRepository));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Repository, &_tc_TAO_tc_CORBA_Repository)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentRepository, &_tc_TAO_tc_IR_ComponentRepository)
 TAO_NAMESPACE_END
-CORBA_ModuleDef_ptr CORBA_ModuleDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ModuleDef::_tao_any_destructor (void *x)
+{
+  ModuleDef *tmp = ACE_static_cast (ModuleDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ModuleDef_ptr IR::ModuleDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ModuleDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ModuleDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_ModuleDef::_nil ());
+    return ModuleDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ModuleDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ModuleDef::_nil ());
   if (is_a == 0)
-    return CORBA_ModuleDef::_nil ();
-  return CORBA_ModuleDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return ModuleDef::_nil ();
+  return ModuleDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_ModuleDef_ptr CORBA_ModuleDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::ModuleDef_ptr IR::ModuleDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ModuleDef::_nil ();
+    return ModuleDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  ModuleDef_ptr default_proxy = ModuleDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ModuleDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_ModuleDef_ptr retv = _TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_ModuleDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_ModuleDef_ptr retval = CORBA_ModuleDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_ModuleDef (stub),
-                  CORBA_ModuleDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ModuleDef (stub), ModuleDef::_nil ());
+  return TAO_IR_ModuleDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_ModuleDef_ptr
-CORBA_ModuleDef::_duplicate (CORBA_ModuleDef_ptr obj)
+IR::ModuleDef_ptr 
+IR::ModuleDef::_duplicate (ModuleDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::Boolean CORBA_ModuleDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::ModuleDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ModuleDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ModuleDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -4173,422 +9732,844 @@ CORBA::Boolean CORBA_ModuleDef::_is_a (const CORBA::Char *value, CORBA_Environme
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_ModuleDef::_interface_repository_id (void) const
+const char* IR::ModuleDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ModuleDef:1.0";
+}
+
+IR::TAO_IR_ModuleDef_Default_Proxy_Factory::TAO_IR_ModuleDef_Default_Proxy_Factory (int register_proxy_factory)
 {
-  return "IDL:omg.org/CORBA/ModuleDef:1.0";
+  if (register_proxy_factory)
+    {
+      TAO_IR_ModuleDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
 }
 
-static const CORBA::Long _oc_CORBA_ModuleDef[] =
+IR::TAO_IR_ModuleDef_Default_Proxy_Factory::~TAO_IR_ModuleDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ModuleDef_ptr
+IR::TAO_IR_ModuleDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ModuleDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ModuleDef_Proxy_Factory_Adapter::TAO_IR_ModuleDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ModuleDef_Proxy_Factory_Adapter::~TAO_IR_ModuleDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ModuleDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ModuleDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ModuleDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::ModuleDef_ptr
+IR::TAO_IR_ModuleDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ModuleDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ModuleDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_ModuleDef_Smart_Proxy_Base::TAO_IR_ModuleDef_Smart_Proxy_Base (::IR::ModuleDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ModuleDef_Smart_Proxy_Base::~TAO_IR_ModuleDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ModuleDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ModuleDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ModuleDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ModuleDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4d6f), ACE_NTOHL (0x64756c65), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ModuleDef:1.0
+  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4d), ACE_NTOHL (0x6f64756c), ACE_NTOHL (0x65446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ModuleDef:1.0
   10, ACE_NTOHL (0x4d6f6475), ACE_NTOHL (0x6c654465), ACE_NTOHL (0x66000000),  // name = ModuleDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ModuleDef (CORBA::tk_objref, sizeof (_oc_CORBA_ModuleDef), (char *) &_oc_CORBA_ModuleDef, 0, sizeof (CORBA_ModuleDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_ModuleDef (CORBA::tk_objref, sizeof (_oc_IR_ModuleDef), (char *) &_oc_IR_ModuleDef, 0, sizeof (IR::ModuleDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ModuleDef, &_tc_TAO_tc_CORBA_ModuleDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ModuleDef, &_tc_TAO_tc_IR_ModuleDef)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_ModuleDescription[] =
+static const CORBA::Long _oc_IR_ModuleDescription[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4d6f), ACE_NTOHL (0x64756c65), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ModuleDescription:1.0
+  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4d), ACE_NTOHL (0x6f64756c), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ModuleDescription:1.0
   18, ACE_NTOHL (0x4d6f6475), ACE_NTOHL (0x6c654465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e000000),  // name = ModuleDescription
   4, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ModuleDescription (CORBA::tk_struct, sizeof (_oc_CORBA_ModuleDescription), (char *) &_oc_CORBA_ModuleDescription, 0, sizeof (CORBA_ModuleDescription));
+static CORBA::TypeCode _tc_TAO_tc_IR_ModuleDescription (CORBA::tk_struct, sizeof (_oc_IR_ModuleDescription), (char *) &_oc_IR_ModuleDescription, 0, sizeof (IR::ModuleDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ModuleDescription, &_tc_TAO_tc_CORBA_ModuleDescription)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ModuleDescription, &_tc_TAO_tc_IR_ModuleDescription)
 TAO_NAMESPACE_END
-CORBA_ConstantDef_ptr CORBA_ConstantDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ModuleDescription::_tao_any_destructor (void *x)
+{
+  ModuleDescription *tmp = ACE_static_cast (ModuleDescription*,x);
+  delete tmp;
+}
+
+void IR::ConstantDef::_tao_any_destructor (void *x)
+{
+  ConstantDef *tmp = ACE_static_cast (ConstantDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ConstantDef_ptr IR::ConstantDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ConstantDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ConstantDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_ConstantDef::_nil ());
+    return ConstantDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ConstantDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ConstantDef::_nil ());
   if (is_a == 0)
-    return CORBA_ConstantDef::_nil ();
-  return CORBA_ConstantDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return ConstantDef::_nil ();
+  return ConstantDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_ConstantDef_ptr CORBA_ConstantDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::ConstantDef_ptr IR::ConstantDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ConstantDef::_nil ();
+    return ConstantDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  ConstantDef_ptr default_proxy = ConstantDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ConstantDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_ConstantDef_ptr retv = _TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_ConstantDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_ConstantDef_ptr retval = CORBA_ConstantDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_ConstantDef (stub),
-                  CORBA_ConstantDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ConstantDef (stub), ConstantDef::_nil ());
+  return TAO_IR_ConstantDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_ConstantDef_ptr
-CORBA_ConstantDef::_duplicate (CORBA_ConstantDef_ptr obj)
+IR::ConstantDef_ptr 
+IR::ConstantDef::_duplicate (ConstantDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::TypeCode_ptr CORBA_ConstantDef::type (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::TypeCode_ptr IR::ConstantDef::type (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::TypeCode_ptr _tao_retval = 0;
-
-
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""type",
+      "_get_type",
       9,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_IDLType_ptr CORBA_ConstantDef::type_def (
-    CORBA_Environment &ACE_TRY_ENV
+IR::IDLType_ptr IR::ConstantDef::type_def (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_IDLType_ptr _tao_retval = CORBA_IDLType::_nil ();
-
-
+  
+  IR::IDLType_ptr _tao_retval = IR::IDLType::_nil ();
+  IR::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""type_def",
+      "_get_type_def",
       13,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ConstantDef::type_def (
-    CORBA_IDLType_ptr type_def,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ConstantDef::type_def (
+    IR::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""type_def",
+      "_set_type_def",
       13,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << type_def)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << type_def)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA_Any * CORBA_ConstantDef::value (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::Any * IR::ConstantDef::value (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_Any* _tao_retval = 0;
-
-
+  
+  CORBA::Any *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-  ACE_NEW_RETURN (_tao_retval, CORBA_Any, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, CORBA::Any, _tao_retval);
+  CORBA::Any_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""value",
+      "_get_value",
       10,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_value",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ConstantDef::value (
-    const CORBA_Any & value,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ConstantDef::value (
+    const CORBA::Any & value,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""value",
+      "_set_value",
       10,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << value)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << value)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_value",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_ConstantDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::ConstantDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ConstantDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ConstantDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -4596,62 +10577,257 @@ CORBA::Boolean CORBA_ConstantDef::_is_a (const CORBA::Char *value, CORBA_Environ
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_ConstantDef::_interface_repository_id (void) const
+const char* IR::ConstantDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ConstantDef:1.0";
+}
+
+IR::TAO_IR_ConstantDef_Default_Proxy_Factory::TAO_IR_ConstantDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_ConstantDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ConstantDef_Default_Proxy_Factory::~TAO_IR_ConstantDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ConstantDef_ptr
+IR::TAO_IR_ConstantDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ConstantDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ConstantDef_Proxy_Factory_Adapter::TAO_IR_ConstantDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ConstantDef_Proxy_Factory_Adapter::~TAO_IR_ConstantDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ConstantDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ConstantDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ConstantDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::ConstantDef_ptr
+IR::TAO_IR_ConstantDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ConstantDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ConstantDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_ConstantDef_Smart_Proxy_Base::TAO_IR_ConstantDef_Smart_Proxy_Base (::IR::ConstantDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ConstantDef_Smart_Proxy_Base::~TAO_IR_ConstantDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ConstantDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::TypeCode_ptr IR::TAO_IR_ConstantDef_Smart_Proxy_Base::type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  return "IDL:omg.org/CORBA/ConstantDef:1.0";
+  return this->base_proxy_->type (
+      ACE_TRY_ENV
+    );
+
 }
 
-static const CORBA::Long _oc_CORBA_ConstantDef[] =
+IR::IDLType_ptr IR::TAO_IR_ConstantDef_Smart_Proxy_Base::type_def  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->type_def (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_ConstantDef_Smart_Proxy_Base::type_def  (
+    IR::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->type_def (
+      type_def,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::Any * IR::TAO_IR_ConstantDef_Smart_Proxy_Base::value  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->value (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_ConstantDef_Smart_Proxy_Base::value  (
+    const CORBA::Any & value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->value (
+      value,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ConstantDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ConstantDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ConstantDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e737461), ACE_NTOHL (0x6e744465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ConstantDef:1.0
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7374), ACE_NTOHL (0x616e7444), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConstantDef:1.0
   12, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x74616e74), ACE_NTOHL (0x44656600),  // name = ConstantDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ConstantDef (CORBA::tk_objref, sizeof (_oc_CORBA_ConstantDef), (char *) &_oc_CORBA_ConstantDef, 0, sizeof (CORBA_ConstantDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_ConstantDef (CORBA::tk_objref, sizeof (_oc_IR_ConstantDef), (char *) &_oc_IR_ConstantDef, 0, sizeof (IR::ConstantDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConstantDef, &_tc_TAO_tc_CORBA_ConstantDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConstantDef, &_tc_TAO_tc_IR_ConstantDef)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_ConstantDescription[] =
+static const CORBA::Long _oc_IR_ConstantDescription[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  42, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e737461), ACE_NTOHL (0x6e744465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e3a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ConstantDescription:1.0
+  39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7374), ACE_NTOHL (0x616e7444), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConstantDescription:1.0
   20, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x74616e74), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = ConstantDescription
   6, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
   5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -4661,64 +10837,71 @@ static const CORBA::Long _oc_CORBA_ConstantDescription[] =
   CORBA::tk_any,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ConstantDescription (CORBA::tk_struct, sizeof (_oc_CORBA_ConstantDescription), (char *) &_oc_CORBA_ConstantDescription, 0, sizeof (CORBA_ConstantDescription));
+static CORBA::TypeCode _tc_TAO_tc_IR_ConstantDescription (CORBA::tk_struct, sizeof (_oc_IR_ConstantDescription), (char *) &_oc_IR_ConstantDescription, 0, sizeof (IR::ConstantDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConstantDescription, &_tc_TAO_tc_CORBA_ConstantDescription)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConstantDescription, &_tc_TAO_tc_IR_ConstantDescription)
 TAO_NAMESPACE_END
-CORBA_TypedefDef_ptr CORBA_TypedefDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ConstantDescription::_tao_any_destructor (void *x)
+{
+  ConstantDescription *tmp = ACE_static_cast (ConstantDescription*,x);
+  delete tmp;
+}
+
+void IR::TypedefDef::_tao_any_destructor (void *x)
+{
+  TypedefDef *tmp = ACE_static_cast (TypedefDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::TypedefDef_ptr IR::TypedefDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_TypedefDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/TypedefDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_TypedefDef::_nil ());
+    return TypedefDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/TypedefDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (TypedefDef::_nil ());
   if (is_a == 0)
-    return CORBA_TypedefDef::_nil ();
-  return CORBA_TypedefDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return TypedefDef::_nil ();
+  return TypedefDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_TypedefDef_ptr CORBA_TypedefDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::TypedefDef_ptr IR::TypedefDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_TypedefDef::_nil ();
+    return TypedefDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  TypedefDef_ptr default_proxy = TypedefDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_TypedefDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_TypedefDef_ptr retv = _TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_TypedefDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_TypedefDef_ptr retval = CORBA_TypedefDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_TypedefDef (stub),
-                  CORBA_TypedefDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, TypedefDef (stub), TypedefDef::_nil ());
+  return TAO_IR_TypedefDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_TypedefDef_ptr
-CORBA_TypedefDef::_duplicate (CORBA_TypedefDef_ptr obj)
+IR::TypedefDef_ptr 
+IR::TypedefDef::_duplicate (TypedefDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::Boolean CORBA_TypedefDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::TypedefDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -4726,249 +10909,497 @@ CORBA::Boolean CORBA_TypedefDef::_is_a (const CORBA::Char *value, CORBA_Environm
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_TypedefDef::_interface_repository_id (void) const
+const char* IR::TypedefDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/TypedefDef:1.0";
+}
+
+IR::TAO_IR_TypedefDef_Default_Proxy_Factory::TAO_IR_TypedefDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_TypedefDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_TypedefDef_Default_Proxy_Factory::~TAO_IR_TypedefDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::TypedefDef_ptr
+IR::TAO_IR_TypedefDef_Default_Proxy_Factory::create_proxy (
+    ::IR::TypedefDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_TypedefDef_Proxy_Factory_Adapter::TAO_IR_TypedefDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_TypedefDef_Proxy_Factory_Adapter::~TAO_IR_TypedefDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_TypedefDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_TypedefDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_TypedefDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::TypedefDef_ptr
+IR::TAO_IR_TypedefDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::TypedefDef_ptr proxy,
+    CORBA::Environment &
+  )
 {
-  return "IDL:omg.org/CORBA/TypedefDef:1.0";
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_TypedefDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
 }
 
-static const CORBA::Long _oc_CORBA_TypedefDef[] =
+IR::TAO_IR_TypedefDef_Smart_Proxy_Base::TAO_IR_TypedefDef_Smart_Proxy_Base (::IR::TypedefDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_TypedefDef_Smart_Proxy_Base::~TAO_IR_TypedefDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_TypedefDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_TypedefDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_TypedefDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_TypedefDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5479), ACE_NTOHL (0x70656465), ACE_NTOHL (0x66446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/TypedefDef:1.0
+  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f54), ACE_NTOHL (0x79706564), ACE_NTOHL (0x65664465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/TypedefDef:1.0
   11, ACE_NTOHL (0x54797065), ACE_NTOHL (0x64656644), ACE_NTOHL (0x65660000),  // name = TypedefDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_TypedefDef (CORBA::tk_objref, sizeof (_oc_CORBA_TypedefDef), (char *) &_oc_CORBA_TypedefDef, 0, sizeof (CORBA_TypedefDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_TypedefDef (CORBA::tk_objref, sizeof (_oc_IR_TypedefDef), (char *) &_oc_IR_TypedefDef, 0, sizeof (IR::TypedefDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypedefDef, &_tc_TAO_tc_CORBA_TypedefDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypedefDef, &_tc_TAO_tc_IR_TypedefDef)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_TypeDescription[] =
+static const CORBA::Long _oc_IR_TypeDescription[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5479), ACE_NTOHL (0x70654465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e3a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/TypeDescription:1.0
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f54), ACE_NTOHL (0x79706544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/TypeDescription:1.0
   16, ACE_NTOHL (0x54797065), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = TypeDescription
   5, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
   5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
   CORBA::tk_TypeCode,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_TypeDescription (CORBA::tk_struct, sizeof (_oc_CORBA_TypeDescription), (char *) &_oc_CORBA_TypeDescription, 0, sizeof (CORBA_TypeDescription));
+static CORBA::TypeCode _tc_TAO_tc_IR_TypeDescription (CORBA::tk_struct, sizeof (_oc_IR_TypeDescription), (char *) &_oc_IR_TypeDescription, 0, sizeof (IR::TypeDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypeDescription, &_tc_TAO_tc_CORBA_TypeDescription)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypeDescription, &_tc_TAO_tc_IR_TypeDescription)
 TAO_NAMESPACE_END
-CORBA_StructDef_ptr CORBA_StructDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::TypeDescription::_tao_any_destructor (void *x)
+{
+  TypeDescription *tmp = ACE_static_cast (TypeDescription*,x);
+  delete tmp;
+}
+
+void IR::StructDef::_tao_any_destructor (void *x)
+{
+  StructDef *tmp = ACE_static_cast (StructDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::StructDef_ptr IR::StructDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_StructDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/StructDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_StructDef::_nil ());
+    return StructDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/StructDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (StructDef::_nil ());
   if (is_a == 0)
-    return CORBA_StructDef::_nil ();
-  return CORBA_StructDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return StructDef::_nil ();
+  return StructDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_StructDef_ptr CORBA_StructDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::StructDef_ptr IR::StructDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_StructDef::_nil ();
+    return StructDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  StructDef_ptr default_proxy = StructDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_StructDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_StructDef_ptr retv = _TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_StructDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_StructDef_ptr retval = CORBA_StructDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_StructDef (stub),
-                  CORBA_StructDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, StructDef (stub), StructDef::_nil ());
+  return TAO_IR_StructDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_StructDef_ptr
-CORBA_StructDef::_duplicate (CORBA_StructDef_ptr obj)
+IR::StructDef_ptr 
+IR::StructDef::_duplicate (StructDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA_StructMemberSeq * CORBA_StructDef::members (
-    CORBA_Environment &ACE_TRY_ENV
+IR::StructMemberSeq * IR::StructDef::members (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_StructMemberSeq* _tao_retval = 0;
-
-
+  
+  IR::StructMemberSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-  ACE_NEW_RETURN (_tao_retval, CORBA_StructMemberSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::StructMemberSeq, _tao_retval);
+  IR::StructMemberSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""members",
+      "_get_members",
       12,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_members",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_StructDef::members (
-    const CORBA_StructMemberSeq & members,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::StructDef::members (
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""members",
+      "_set_members",
       12,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << members)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_members",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_StructDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::StructDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/StructDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/StructDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -4976,377 +11407,803 @@ CORBA::Boolean CORBA_StructDef::_is_a (const CORBA::Char *value, CORBA_Environme
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_StructDef::_interface_repository_id (void) const
+const char* IR::StructDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/StructDef:1.0";
+}
+
+IR::TAO_IR_StructDef_Default_Proxy_Factory::TAO_IR_StructDef_Default_Proxy_Factory (int register_proxy_factory)
 {
-  return "IDL:omg.org/CORBA/StructDef:1.0";
+  if (register_proxy_factory)
+    {
+      TAO_IR_StructDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
 }
 
-static const CORBA::Long _oc_CORBA_StructDef[] =
+IR::TAO_IR_StructDef_Default_Proxy_Factory::~TAO_IR_StructDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::StructDef_ptr
+IR::TAO_IR_StructDef_Default_Proxy_Factory::create_proxy (
+    ::IR::StructDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_StructDef_Proxy_Factory_Adapter::TAO_IR_StructDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_StructDef_Proxy_Factory_Adapter::~TAO_IR_StructDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_StructDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_StructDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_StructDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::StructDef_ptr
+IR::TAO_IR_StructDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::StructDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_StructDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_StructDef_Smart_Proxy_Base::TAO_IR_StructDef_Smart_Proxy_Base (::IR::StructDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_StructDef_Smart_Proxy_Base::~TAO_IR_StructDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_StructDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::StructMemberSeq * IR::TAO_IR_StructDef_Smart_Proxy_Base::members  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->members (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_StructDef_Smart_Proxy_Base::members  (
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->members (
+      members,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_StructDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_StructDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_StructDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/StructDef:1.0
+  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x74446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/StructDef:1.0
   10, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744465), ACE_NTOHL (0x66000000),  // name = StructDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_StructDef (CORBA::tk_objref, sizeof (_oc_CORBA_StructDef), (char *) &_oc_CORBA_StructDef, 0, sizeof (CORBA_StructDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_StructDef (CORBA::tk_objref, sizeof (_oc_IR_StructDef), (char *) &_oc_IR_StructDef, 0, sizeof (IR::StructDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructDef, &_tc_TAO_tc_CORBA_StructDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StructDef, &_tc_TAO_tc_IR_StructDef)
 TAO_NAMESPACE_END
-CORBA_UnionDef_ptr CORBA_UnionDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::UnionDef::_tao_any_destructor (void *x)
+{
+  UnionDef *tmp = ACE_static_cast (UnionDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::UnionDef_ptr IR::UnionDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_UnionDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/UnionDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_UnionDef::_nil ());
+    return UnionDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/UnionDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (UnionDef::_nil ());
   if (is_a == 0)
-    return CORBA_UnionDef::_nil ();
-  return CORBA_UnionDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return UnionDef::_nil ();
+  return UnionDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_UnionDef_ptr CORBA_UnionDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::UnionDef_ptr IR::UnionDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_UnionDef::_nil ();
+    return UnionDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  UnionDef_ptr default_proxy = UnionDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_UnionDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_UnionDef_ptr retv = _TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_UnionDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_UnionDef_ptr retval = CORBA_UnionDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_UnionDef (stub),
-                  CORBA_UnionDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, UnionDef (stub), UnionDef::_nil ());
+  return TAO_IR_UnionDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_UnionDef_ptr
-CORBA_UnionDef::_duplicate (CORBA_UnionDef_ptr obj)
+IR::UnionDef_ptr 
+IR::UnionDef::_duplicate (UnionDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::TypeCode_ptr CORBA_UnionDef::discriminator_type (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::TypeCode_ptr IR::UnionDef::discriminator_type (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::TypeCode_ptr _tao_retval = 0;
-
-
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""discriminator_type",
+      "_get_discriminator_type",
       23,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_discriminator_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_discriminator_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_discriminator_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_IDLType_ptr CORBA_UnionDef::discriminator_type_def (
-    CORBA_Environment &ACE_TRY_ENV
+IR::IDLType_ptr IR::UnionDef::discriminator_type_def (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_IDLType_ptr _tao_retval = CORBA_IDLType::_nil ();
-
-
+  
+  IR::IDLType_ptr _tao_retval = IR::IDLType::_nil ();
+  IR::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""discriminator_type_def",
+      "_get_discriminator_type_def",
       27,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_discriminator_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_discriminator_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_discriminator_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_UnionDef::discriminator_type_def (
-    CORBA_IDLType_ptr discriminator_type_def,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::UnionDef::discriminator_type_def (
+    IR::IDLType_ptr discriminator_type_def,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""discriminator_type_def",
+      "_set_discriminator_type_def",
       27,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << discriminator_type_def)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_discriminator_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << discriminator_type_def)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_discriminator_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_discriminator_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA_UnionMemberSeq * CORBA_UnionDef::members (
-    CORBA_Environment &ACE_TRY_ENV
+IR::UnionMemberSeq * IR::UnionDef::members (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_UnionMemberSeq* _tao_retval = 0;
-
-
+  
+  IR::UnionMemberSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_UnionMemberSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::UnionMemberSeq, _tao_retval);
+  IR::UnionMemberSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""members",
+      "_get_members",
       12,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_members",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_UnionDef::members (
-    const CORBA_UnionMemberSeq & members,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::UnionDef::members (
+    const IR::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""members",
+      "_set_members",
       12,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << members)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_members",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_UnionDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::UnionDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/UnionDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/UnionDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -5354,197 +12211,490 @@ CORBA::Boolean CORBA_UnionDef::_is_a (const CORBA::Char *value, CORBA_Environmen
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_UnionDef::_interface_repository_id (void) const
+const char* IR::UnionDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/UnionDef:1.0";
+}
+
+IR::TAO_IR_UnionDef_Default_Proxy_Factory::TAO_IR_UnionDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_UnionDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_UnionDef_Default_Proxy_Factory::~TAO_IR_UnionDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::UnionDef_ptr
+IR::TAO_IR_UnionDef_Default_Proxy_Factory::create_proxy (
+    ::IR::UnionDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_UnionDef_Proxy_Factory_Adapter::TAO_IR_UnionDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_UnionDef_Proxy_Factory_Adapter::~TAO_IR_UnionDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_UnionDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_UnionDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_UnionDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::UnionDef_ptr
+IR::TAO_IR_UnionDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::UnionDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_UnionDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_UnionDef_Smart_Proxy_Base::TAO_IR_UnionDef_Smart_Proxy_Base (::IR::UnionDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_UnionDef_Smart_Proxy_Base::~TAO_IR_UnionDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_UnionDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::TypeCode_ptr IR::TAO_IR_UnionDef_Smart_Proxy_Base::discriminator_type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->discriminator_type (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::IDLType_ptr IR::TAO_IR_UnionDef_Smart_Proxy_Base::discriminator_type_def  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->discriminator_type_def (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_UnionDef_Smart_Proxy_Base::discriminator_type_def  (
+    IR::IDLType_ptr discriminator_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->discriminator_type_def (
+      discriminator_type_def,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::UnionMemberSeq * IR::TAO_IR_UnionDef_Smart_Proxy_Base::members  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  return "IDL:omg.org/CORBA/UnionDef:1.0";
+  return this->base_proxy_->members (
+      ACE_TRY_ENV
+    );
+
 }
 
-static const CORBA::Long _oc_CORBA_UnionDef[] =
+void IR::TAO_IR_UnionDef_Smart_Proxy_Base::members  (
+    const IR::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->members (
+      members,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_UnionDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_UnionDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_UnionDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f556e), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/UnionDef:1.0
+  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x6e696f6e), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/UnionDef:1.0
   9, ACE_NTOHL (0x556e696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x0),  // name = UnionDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_UnionDef (CORBA::tk_objref, sizeof (_oc_CORBA_UnionDef), (char *) &_oc_CORBA_UnionDef, 0, sizeof (CORBA_UnionDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_UnionDef (CORBA::tk_objref, sizeof (_oc_IR_UnionDef), (char *) &_oc_IR_UnionDef, 0, sizeof (IR::UnionDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionDef, &_tc_TAO_tc_CORBA_UnionDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UnionDef, &_tc_TAO_tc_IR_UnionDef)
 TAO_NAMESPACE_END
-CORBA_EnumDef_ptr CORBA_EnumDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::EnumDef::_tao_any_destructor (void *x)
+{
+  EnumDef *tmp = ACE_static_cast (EnumDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::EnumDef_ptr IR::EnumDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_EnumDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/EnumDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_EnumDef::_nil ());
+    return EnumDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/EnumDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (EnumDef::_nil ());
   if (is_a == 0)
-    return CORBA_EnumDef::_nil ();
-  return CORBA_EnumDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return EnumDef::_nil ();
+  return EnumDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_EnumDef_ptr CORBA_EnumDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::EnumDef_ptr IR::EnumDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_EnumDef::_nil ();
+    return EnumDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  EnumDef_ptr default_proxy = EnumDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_EnumDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_EnumDef_ptr retv = _TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_EnumDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_EnumDef_ptr retval = CORBA_EnumDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_EnumDef (stub),
-                  CORBA_EnumDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, EnumDef (stub), EnumDef::_nil ());
+  return TAO_IR_EnumDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_EnumDef_ptr
-CORBA_EnumDef::_duplicate (CORBA_EnumDef_ptr obj)
+IR::EnumDef_ptr 
+IR::EnumDef::_duplicate (EnumDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA_EnumMemberSeq * CORBA_EnumDef::members (
-    CORBA_Environment &ACE_TRY_ENV
+IR::EnumMemberSeq * IR::EnumDef::members (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_EnumMemberSeq* _tao_retval = 0;
-
-
+  
+  IR::EnumMemberSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_EnumMemberSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::EnumMemberSeq, _tao_retval);
+  IR::EnumMemberSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""members",
+      "_get_members",
       12,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_members",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_EnumDef::members (
-    const CORBA_EnumMemberSeq & members,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::EnumDef::members (
+    const IR::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""members",
+      "_set_members",
       12,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << members)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_members",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_EnumDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::EnumDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/EnumDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EnumDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -5552,196 +12702,662 @@ CORBA::Boolean CORBA_EnumDef::_is_a (const CORBA::Char *value, CORBA_Environment
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_EnumDef::_interface_repository_id (void) const
+const char* IR::EnumDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/EnumDef:1.0";
+}
+
+IR::TAO_IR_EnumDef_Default_Proxy_Factory::TAO_IR_EnumDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_EnumDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_EnumDef_Default_Proxy_Factory::~TAO_IR_EnumDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::EnumDef_ptr
+IR::TAO_IR_EnumDef_Default_Proxy_Factory::create_proxy (
+    ::IR::EnumDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_EnumDef_Proxy_Factory_Adapter::TAO_IR_EnumDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_EnumDef_Proxy_Factory_Adapter::~TAO_IR_EnumDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_EnumDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_EnumDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_EnumDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::EnumDef_ptr
+IR::TAO_IR_EnumDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::EnumDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_EnumDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_EnumDef_Smart_Proxy_Base::TAO_IR_EnumDef_Smart_Proxy_Base (::IR::EnumDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_EnumDef_Smart_Proxy_Base::~TAO_IR_EnumDef_Smart_Proxy_Base (void)
 {
-  return "IDL:omg.org/CORBA/EnumDef:1.0";
 }
 
-static const CORBA::Long _oc_CORBA_EnumDef[] =
+TAO_Stub *
+IR::TAO_IR_EnumDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::EnumMemberSeq * IR::TAO_IR_EnumDef_Smart_Proxy_Base::members  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->members (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_EnumDef_Smart_Proxy_Base::members  (
+    const IR::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->members (
+      members,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_EnumDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_EnumDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_EnumDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f456e), ACE_NTOHL (0x756d4465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/EnumDef:1.0
+  27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6e756d44), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/EnumDef:1.0
   8, ACE_NTOHL (0x456e756d), ACE_NTOHL (0x44656600),  // name = EnumDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_EnumDef (CORBA::tk_objref, sizeof (_oc_CORBA_EnumDef), (char *) &_oc_CORBA_EnumDef, 0, sizeof (CORBA_EnumDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_EnumDef (CORBA::tk_objref, sizeof (_oc_IR_EnumDef), (char *) &_oc_IR_EnumDef, 0, sizeof (IR::EnumDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnumDef, &_tc_TAO_tc_CORBA_EnumDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EnumDef, &_tc_TAO_tc_IR_EnumDef)
 TAO_NAMESPACE_END
-CORBA_AliasDef_ptr CORBA_AliasDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::AliasDef::_tao_any_destructor (void *x)
+{
+  AliasDef *tmp = ACE_static_cast (AliasDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::AliasDef_ptr IR::AliasDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_AliasDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/AliasDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_AliasDef::_nil ());
+    return AliasDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/AliasDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (AliasDef::_nil ());
   if (is_a == 0)
-    return CORBA_AliasDef::_nil ();
-  return CORBA_AliasDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return AliasDef::_nil ();
+  return AliasDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_AliasDef_ptr CORBA_AliasDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::AliasDef_ptr IR::AliasDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_AliasDef::_nil ();
+    return AliasDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  AliasDef_ptr default_proxy = AliasDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_AliasDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_AliasDef_ptr retv = _TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_AliasDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_AliasDef_ptr retval = CORBA_AliasDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_AliasDef (stub),
-                  CORBA_AliasDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, AliasDef (stub), AliasDef::_nil ());
+  return TAO_IR_AliasDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_AliasDef_ptr
-CORBA_AliasDef::_duplicate (CORBA_AliasDef_ptr obj)
+IR::AliasDef_ptr 
+IR::AliasDef::_duplicate (AliasDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA_IDLType_ptr CORBA_AliasDef::original_type_def (
-    CORBA_Environment &ACE_TRY_ENV
+IR::IDLType_ptr IR::AliasDef::original_type_def (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_IDLType_ptr _tao_retval = CORBA_IDLType::_nil ();
-
-
+  
+  IR::IDLType_ptr _tao_retval = IR::IDLType::_nil ();
+  IR::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""original_type_def",
+      "_get_original_type_def",
       22,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_original_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_original_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_original_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_AliasDef::original_type_def (
-    CORBA_IDLType_ptr original_type_def,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::AliasDef::original_type_def (
+    IR::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""original_type_def",
+      "_set_original_type_def",
       22,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
-    CORBA::Short flag = 131;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_original_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << original_type_def)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_original_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_original_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << original_type_def)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK;
+CORBA::Boolean IR::AliasDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/AliasDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+const char* IR::AliasDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/AliasDef:1.0";
+}
+
+IR::TAO_IR_AliasDef_Default_Proxy_Factory::TAO_IR_AliasDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
     {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+      TAO_IR_AliasDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_AliasDef_Default_Proxy_Factory::~TAO_IR_AliasDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::AliasDef_ptr
+IR::TAO_IR_AliasDef_Default_Proxy_Factory::create_proxy (
+    ::IR::AliasDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_AliasDef_Proxy_Factory_Adapter::TAO_IR_AliasDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_AliasDef_Proxy_Factory_Adapter::~TAO_IR_AliasDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
 
+int
+IR::TAO_IR_AliasDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_AliasDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_AliasDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
     }
-    break;
+return 0;
+}
 
-  }
+IR::AliasDef_ptr
+IR::TAO_IR_AliasDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::AliasDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_AliasDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
 
+IR::TAO_IR_AliasDef_Smart_Proxy_Base::TAO_IR_AliasDef_Smart_Proxy_Base (::IR::AliasDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_AliasDef_Smart_Proxy_Base::~TAO_IR_AliasDef_Smart_Proxy_Base (void)
+{
 }
 
-CORBA::Boolean CORBA_AliasDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+TAO_Stub *
+IR::TAO_IR_AliasDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::IDLType_ptr IR::TAO_IR_AliasDef_Smart_Proxy_Base::original_type_def  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->original_type_def (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_AliasDef_Smart_Proxy_Base::original_type_def  (
+    IR::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->original_type_def (
+      original_type_def,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_AliasDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_AliasDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_AliasDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x6c696173), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AliasDef:1.0
+  9, ACE_NTOHL (0x416c6961), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = AliasDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_AliasDef (CORBA::tk_objref, sizeof (_oc_IR_AliasDef), (char *) &_oc_IR_AliasDef, 0, sizeof (IR::AliasDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AliasDef, &_tc_TAO_tc_IR_AliasDef)
+TAO_NAMESPACE_END
+void IR::NativeDef::_tao_any_destructor (void *x)
+{
+  NativeDef *tmp = ACE_static_cast (NativeDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::NativeDef_ptr IR::NativeDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return NativeDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/NativeDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (NativeDef::_nil ());
+  if (is_a == 0)
+    return NativeDef::_nil ();
+  return NativeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::NativeDef_ptr IR::NativeDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return NativeDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  NativeDef_ptr default_proxy = NativeDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_NativeDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_NativeDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, NativeDef (stub), NativeDef::_nil ());
+  return TAO_IR_NativeDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::NativeDef_ptr 
+IR::NativeDef::_duplicate (NativeDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+CORBA::Boolean IR::NativeDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/AliasDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/NativeDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -5749,133 +13365,300 @@ CORBA::Boolean CORBA_AliasDef::_is_a (const CORBA::Char *value, CORBA_Environmen
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_AliasDef::_interface_repository_id (void) const
+const char* IR::NativeDef::_interface_repository_id (void) const
 {
-  return "IDL:omg.org/CORBA/AliasDef:1.0";
+  return "IDL:omg.org/IR/NativeDef:1.0";
 }
 
-static const CORBA::Long _oc_CORBA_AliasDef[] =
+IR::TAO_IR_NativeDef_Default_Proxy_Factory::TAO_IR_NativeDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_NativeDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_NativeDef_Default_Proxy_Factory::~TAO_IR_NativeDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::NativeDef_ptr
+IR::TAO_IR_NativeDef_Default_Proxy_Factory::create_proxy (
+    ::IR::NativeDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_NativeDef_Proxy_Factory_Adapter::TAO_IR_NativeDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_NativeDef_Proxy_Factory_Adapter::~TAO_IR_NativeDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_NativeDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_NativeDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_NativeDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::NativeDef_ptr
+IR::TAO_IR_NativeDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::NativeDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_NativeDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_NativeDef_Smart_Proxy_Base::TAO_IR_NativeDef_Smart_Proxy_Base (::IR::NativeDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_NativeDef_Smart_Proxy_Base::~TAO_IR_NativeDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_NativeDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_NativeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_NativeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_NativeDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f416c), ACE_NTOHL (0x69617344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AliasDef:1.0
-  9, ACE_NTOHL (0x416c6961), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = AliasDef
+  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4e), ACE_NTOHL (0x61746976), ACE_NTOHL (0x65446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/NativeDef:1.0
+  10, ACE_NTOHL (0x4e617469), ACE_NTOHL (0x76654465), ACE_NTOHL (0x66000000),  // name = NativeDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_AliasDef (CORBA::tk_objref, sizeof (_oc_CORBA_AliasDef), (char *) &_oc_CORBA_AliasDef, 0, sizeof (CORBA_AliasDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_NativeDef (CORBA::tk_objref, sizeof (_oc_IR_NativeDef), (char *) &_oc_IR_NativeDef, 0, sizeof (IR::NativeDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AliasDef, &_tc_TAO_tc_CORBA_AliasDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_NativeDef, &_tc_TAO_tc_IR_NativeDef)
 TAO_NAMESPACE_END
-CORBA_PrimitiveDef_ptr CORBA_PrimitiveDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::PrimitiveDef::_tao_any_destructor (void *x)
+{
+  PrimitiveDef *tmp = ACE_static_cast (PrimitiveDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::PrimitiveDef_ptr IR::PrimitiveDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_PrimitiveDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/PrimitiveDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_PrimitiveDef::_nil ());
+    return PrimitiveDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/PrimitiveDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (PrimitiveDef::_nil ());
   if (is_a == 0)
-    return CORBA_PrimitiveDef::_nil ();
-  return CORBA_PrimitiveDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return PrimitiveDef::_nil ();
+  return PrimitiveDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_PrimitiveDef_ptr CORBA_PrimitiveDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::PrimitiveDef_ptr IR::PrimitiveDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_PrimitiveDef::_nil ();
+    return PrimitiveDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  PrimitiveDef_ptr default_proxy = PrimitiveDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_PrimitiveDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_PrimitiveDef_ptr retv = _TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_PrimitiveDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_PrimitiveDef_ptr retval = CORBA_PrimitiveDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_PrimitiveDef (stub),
-                  CORBA_PrimitiveDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, PrimitiveDef (stub), PrimitiveDef::_nil ());
+  return TAO_IR_PrimitiveDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_PrimitiveDef_ptr
-CORBA_PrimitiveDef::_duplicate (CORBA_PrimitiveDef_ptr obj)
+IR::PrimitiveDef_ptr 
+IR::PrimitiveDef::_duplicate (PrimitiveDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::PrimitiveKind CORBA_PrimitiveDef::kind (
-    CORBA_Environment &ACE_TRY_ENV
+IR::PrimitiveKind IR::PrimitiveDef::kind (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::PrimitiveKind _tao_retval = (CORBA::PrimitiveKind)0;
-
-
+  
+  IR::PrimitiveKind _tao_retval = (IR::PrimitiveKind)0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""kind",
+      "_get_kind",
       9,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_kind",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_kind",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_kind",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-CORBA::Boolean CORBA_PrimitiveDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::PrimitiveDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/PrimitiveDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/PrimitiveDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -5883,194 +13666,430 @@ CORBA::Boolean CORBA_PrimitiveDef::_is_a (const CORBA::Char *value, CORBA_Enviro
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_PrimitiveDef::_interface_repository_id (void) const
+const char* IR::PrimitiveDef::_interface_repository_id (void) const
 {
-  return "IDL:omg.org/CORBA/PrimitiveDef:1.0";
+  return "IDL:omg.org/IR/PrimitiveDef:1.0";
 }
 
-static const CORBA::Long _oc_CORBA_PrimitiveDef[] =
+IR::TAO_IR_PrimitiveDef_Default_Proxy_Factory::TAO_IR_PrimitiveDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_PrimitiveDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_PrimitiveDef_Default_Proxy_Factory::~TAO_IR_PrimitiveDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::PrimitiveDef_ptr
+IR::TAO_IR_PrimitiveDef_Default_Proxy_Factory::create_proxy (
+    ::IR::PrimitiveDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_PrimitiveDef_Proxy_Factory_Adapter::TAO_IR_PrimitiveDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_PrimitiveDef_Proxy_Factory_Adapter::~TAO_IR_PrimitiveDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_PrimitiveDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_PrimitiveDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_PrimitiveDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::PrimitiveDef_ptr
+IR::TAO_IR_PrimitiveDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::PrimitiveDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_PrimitiveDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_PrimitiveDef_Smart_Proxy_Base::TAO_IR_PrimitiveDef_Smart_Proxy_Base (::IR::PrimitiveDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_PrimitiveDef_Smart_Proxy_Base::~TAO_IR_PrimitiveDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_PrimitiveDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::PrimitiveKind IR::TAO_IR_PrimitiveDef_Smart_Proxy_Base::kind  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->kind (
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_PrimitiveDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_PrimitiveDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_PrimitiveDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5072), ACE_NTOHL (0x696d6974), ACE_NTOHL (0x69766544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/PrimitiveDef:1.0
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d69), ACE_NTOHL (0x74697665), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PrimitiveDef:1.0
   13, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x69746976), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = PrimitiveDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_PrimitiveDef (CORBA::tk_objref, sizeof (_oc_CORBA_PrimitiveDef), (char *) &_oc_CORBA_PrimitiveDef, 0, sizeof (CORBA_PrimitiveDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_PrimitiveDef (CORBA::tk_objref, sizeof (_oc_IR_PrimitiveDef), (char *) &_oc_IR_PrimitiveDef, 0, sizeof (IR::PrimitiveDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimitiveDef, &_tc_TAO_tc_CORBA_PrimitiveDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimitiveDef, &_tc_TAO_tc_IR_PrimitiveDef)
 TAO_NAMESPACE_END
-CORBA_StringDef_ptr CORBA_StringDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::StringDef::_tao_any_destructor (void *x)
+{
+  StringDef *tmp = ACE_static_cast (StringDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::StringDef_ptr IR::StringDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_StringDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/StringDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_StringDef::_nil ());
+    return StringDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/StringDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (StringDef::_nil ());
   if (is_a == 0)
-    return CORBA_StringDef::_nil ();
-  return CORBA_StringDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return StringDef::_nil ();
+  return StringDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_StringDef_ptr CORBA_StringDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::StringDef_ptr IR::StringDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_StringDef::_nil ();
+    return StringDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  StringDef_ptr default_proxy = StringDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_StringDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_StringDef_ptr retv = _TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_StringDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_StringDef_ptr retval = CORBA_StringDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_StringDef (stub),
-                  CORBA_StringDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, StringDef (stub), StringDef::_nil ());
+  return TAO_IR_StringDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_StringDef_ptr
-CORBA_StringDef::_duplicate (CORBA_StringDef_ptr obj)
+IR::StringDef_ptr 
+IR::StringDef::_duplicate (StringDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::ULong CORBA_StringDef::bound (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::ULong IR::StringDef::bound (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
+  
   CORBA::ULong _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""bound",
+      "_get_bound",
       10,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_bound",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_StringDef::bound (
+void IR::StringDef::bound (
     CORBA::ULong bound,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""bound",
+      "_set_bound",
       10,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-     CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << bound)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << bound)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_bound",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_StringDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::StringDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/StringDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/StringDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -6078,194 +14097,445 @@ CORBA::Boolean CORBA_StringDef::_is_a (const CORBA::Char *value, CORBA_Environme
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_StringDef::_interface_repository_id (void) const
+const char* IR::StringDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/StringDef:1.0";
+}
+
+IR::TAO_IR_StringDef_Default_Proxy_Factory::TAO_IR_StringDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_StringDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_StringDef_Default_Proxy_Factory::~TAO_IR_StringDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::StringDef_ptr
+IR::TAO_IR_StringDef_Default_Proxy_Factory::create_proxy (
+    ::IR::StringDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_StringDef_Proxy_Factory_Adapter::TAO_IR_StringDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_StringDef_Proxy_Factory_Adapter::~TAO_IR_StringDef_Proxy_Factory_Adapter (void)
 {
-  return "IDL:omg.org/CORBA/StringDef:1.0";
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
 }
 
-static const CORBA::Long _oc_CORBA_StringDef[] =
+int
+IR::TAO_IR_StringDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_StringDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_StringDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::StringDef_ptr
+IR::TAO_IR_StringDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::StringDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_StringDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_StringDef_Smart_Proxy_Base::TAO_IR_StringDef_Smart_Proxy_Base (::IR::StringDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_StringDef_Smart_Proxy_Base::~TAO_IR_StringDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_StringDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::ULong IR::TAO_IR_StringDef_Smart_Proxy_Base::bound  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->bound (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_StringDef_Smart_Proxy_Base::bound  (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->bound (
+      bound,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_StringDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_StringDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_StringDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72696e67), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/StringDef:1.0
+  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x7472696e), ACE_NTOHL (0x67446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/StringDef:1.0
   10, ACE_NTOHL (0x53747269), ACE_NTOHL (0x6e674465), ACE_NTOHL (0x66000000),  // name = StringDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_StringDef (CORBA::tk_objref, sizeof (_oc_CORBA_StringDef), (char *) &_oc_CORBA_StringDef, 0, sizeof (CORBA_StringDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_StringDef (CORBA::tk_objref, sizeof (_oc_IR_StringDef), (char *) &_oc_IR_StringDef, 0, sizeof (IR::StringDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StringDef, &_tc_TAO_tc_CORBA_StringDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_StringDef, &_tc_TAO_tc_IR_StringDef)
 TAO_NAMESPACE_END
-CORBA_WstringDef_ptr CORBA_WstringDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::WstringDef::_tao_any_destructor (void *x)
+{
+  WstringDef *tmp = ACE_static_cast (WstringDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::WstringDef_ptr IR::WstringDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_WstringDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/WstringDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_WstringDef::_nil ());
+    return WstringDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/WstringDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (WstringDef::_nil ());
   if (is_a == 0)
-    return CORBA_WstringDef::_nil ();
-  return CORBA_WstringDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return WstringDef::_nil ();
+  return WstringDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_WstringDef_ptr CORBA_WstringDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::WstringDef_ptr IR::WstringDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_WstringDef::_nil ();
+    return WstringDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  WstringDef_ptr default_proxy = WstringDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_WstringDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_WstringDef_ptr retv = _TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_WstringDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_WstringDef_ptr retval = CORBA_WstringDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_WstringDef (stub),
-                  CORBA_WstringDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, WstringDef (stub), WstringDef::_nil ());
+  return TAO_IR_WstringDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_WstringDef_ptr
-CORBA_WstringDef::_duplicate (CORBA_WstringDef_ptr obj)
+IR::WstringDef_ptr 
+IR::WstringDef::_duplicate (WstringDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::ULong CORBA_WstringDef::bound (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::ULong IR::WstringDef::bound (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
+  
   CORBA::ULong _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""bound",
+      "_get_bound",
       10,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_bound",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_WstringDef::bound (
+void IR::WstringDef::bound (
     CORBA::ULong bound,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""bound",
+      "_set_bound",
       10,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << bound)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << bound)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_bound",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_WstringDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::WstringDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/WstringDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/WstringDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -6273,314 +14543,679 @@ CORBA::Boolean CORBA_WstringDef::_is_a (const CORBA::Char *value, CORBA_Environm
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_WstringDef::_interface_repository_id (void) const
+const char* IR::WstringDef::_interface_repository_id (void) const
 {
-  return "IDL:omg.org/CORBA/WstringDef:1.0";
+  return "IDL:omg.org/IR/WstringDef:1.0";
 }
 
-static const CORBA::Long _oc_CORBA_WstringDef[] =
+IR::TAO_IR_WstringDef_Default_Proxy_Factory::TAO_IR_WstringDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_WstringDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_WstringDef_Default_Proxy_Factory::~TAO_IR_WstringDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::WstringDef_ptr
+IR::TAO_IR_WstringDef_Default_Proxy_Factory::create_proxy (
+    ::IR::WstringDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_WstringDef_Proxy_Factory_Adapter::TAO_IR_WstringDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_WstringDef_Proxy_Factory_Adapter::~TAO_IR_WstringDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_WstringDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_WstringDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_WstringDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::WstringDef_ptr
+IR::TAO_IR_WstringDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::WstringDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_WstringDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_WstringDef_Smart_Proxy_Base::TAO_IR_WstringDef_Smart_Proxy_Base (::IR::WstringDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_WstringDef_Smart_Proxy_Base::~TAO_IR_WstringDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_WstringDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::ULong IR::TAO_IR_WstringDef_Smart_Proxy_Base::bound  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->bound (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_WstringDef_Smart_Proxy_Base::bound  (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->bound (
+      bound,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_WstringDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_WstringDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_WstringDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5773), ACE_NTOHL (0x7472696e), ACE_NTOHL (0x67446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/WstringDef:1.0
+  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f57), ACE_NTOHL (0x73747269), ACE_NTOHL (0x6e674465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/WstringDef:1.0
   11, ACE_NTOHL (0x57737472), ACE_NTOHL (0x696e6744), ACE_NTOHL (0x65660000),  // name = WstringDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_WstringDef (CORBA::tk_objref, sizeof (_oc_CORBA_WstringDef), (char *) &_oc_CORBA_WstringDef, 0, sizeof (CORBA_WstringDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_WstringDef (CORBA::tk_objref, sizeof (_oc_IR_WstringDef), (char *) &_oc_IR_WstringDef, 0, sizeof (IR::WstringDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_WstringDef, &_tc_TAO_tc_CORBA_WstringDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_WstringDef, &_tc_TAO_tc_IR_WstringDef)
 TAO_NAMESPACE_END
-CORBA_FixedDef_ptr CORBA_FixedDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::FixedDef::_tao_any_destructor (void *x)
+{
+  FixedDef *tmp = ACE_static_cast (FixedDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::FixedDef_ptr IR::FixedDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_FixedDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/FixedDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_FixedDef::_nil ());
+    return FixedDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/FixedDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (FixedDef::_nil ());
   if (is_a == 0)
-    return CORBA_FixedDef::_nil ();
-  return CORBA_FixedDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return FixedDef::_nil ();
+  return FixedDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_FixedDef_ptr CORBA_FixedDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::FixedDef_ptr IR::FixedDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_FixedDef::_nil ();
+    return FixedDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  FixedDef_ptr default_proxy = FixedDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_FixedDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_FixedDef_ptr retv = _TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_FixedDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_FixedDef_ptr retval = CORBA_FixedDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_FixedDef (stub),
-                  CORBA_FixedDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, FixedDef (stub), FixedDef::_nil ());
+  return TAO_IR_FixedDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_FixedDef_ptr
-CORBA_FixedDef::_duplicate (CORBA_FixedDef_ptr obj)
+IR::FixedDef_ptr 
+IR::FixedDef::_duplicate (FixedDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::UShort CORBA_FixedDef::digits (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::UShort IR::FixedDef::digits (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
+  
   CORBA::UShort _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""digits",
+      "_get_digits",
       11,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_digits",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_digits",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_digits",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_FixedDef::digits (
+void IR::FixedDef::digits (
     CORBA::UShort digits,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""digits",
+      "_set_digits",
       11,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << digits)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_digits",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << digits)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_digits",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_digits",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Short CORBA_FixedDef::scale (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::Short IR::FixedDef::scale (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
+  
   CORBA::Short _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""scale",
+      "_get_scale",
       10,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_scale",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_scale",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_scale",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_FixedDef::scale (
+void IR::FixedDef::scale (
     CORBA::Short scale,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""scale",
+      "_set_scale",
       10,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << scale)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_scale",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << scale)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_scale",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_scale",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_FixedDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::FixedDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/FixedDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/FixedDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -6588,373 +15223,826 @@ CORBA::Boolean CORBA_FixedDef::_is_a (const CORBA::Char *value, CORBA_Environmen
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_FixedDef::_interface_repository_id (void) const
+const char* IR::FixedDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/FixedDef:1.0";
+}
+
+IR::TAO_IR_FixedDef_Default_Proxy_Factory::TAO_IR_FixedDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_FixedDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_FixedDef_Default_Proxy_Factory::~TAO_IR_FixedDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::FixedDef_ptr
+IR::TAO_IR_FixedDef_Default_Proxy_Factory::create_proxy (
+    ::IR::FixedDef_ptr proxy,
+    CORBA::Environment &
+  )
 {
-  return "IDL:omg.org/CORBA/FixedDef:1.0";
+  return proxy;
 }
 
-static const CORBA::Long _oc_CORBA_FixedDef[] =
+IR::TAO_IR_FixedDef_Proxy_Factory_Adapter::TAO_IR_FixedDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_FixedDef_Proxy_Factory_Adapter::~TAO_IR_FixedDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_FixedDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_FixedDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_FixedDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::FixedDef_ptr
+IR::TAO_IR_FixedDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::FixedDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_FixedDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_FixedDef_Smart_Proxy_Base::TAO_IR_FixedDef_Smart_Proxy_Base (::IR::FixedDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_FixedDef_Smart_Proxy_Base::~TAO_IR_FixedDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_FixedDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::UShort IR::TAO_IR_FixedDef_Smart_Proxy_Base::digits  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->digits (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_FixedDef_Smart_Proxy_Base::digits  (
+    CORBA::UShort digits,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->digits (
+      digits,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::Short IR::TAO_IR_FixedDef_Smart_Proxy_Base::scale  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->scale (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_FixedDef_Smart_Proxy_Base::scale  (
+    CORBA::Short scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->scale (
+      scale,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_FixedDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_FixedDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_FixedDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4669), ACE_NTOHL (0x78656444), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/FixedDef:1.0
+  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x69786564), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/FixedDef:1.0
   9, ACE_NTOHL (0x46697865), ACE_NTOHL (0x64446566), ACE_NTOHL (0x0),  // name = FixedDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_FixedDef (CORBA::tk_objref, sizeof (_oc_CORBA_FixedDef), (char *) &_oc_CORBA_FixedDef, 0, sizeof (CORBA_FixedDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_FixedDef (CORBA::tk_objref, sizeof (_oc_IR_FixedDef), (char *) &_oc_IR_FixedDef, 0, sizeof (IR::FixedDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FixedDef, &_tc_TAO_tc_CORBA_FixedDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FixedDef, &_tc_TAO_tc_IR_FixedDef)
 TAO_NAMESPACE_END
-CORBA_SequenceDef_ptr CORBA_SequenceDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::SequenceDef::_tao_any_destructor (void *x)
+{
+  SequenceDef *tmp = ACE_static_cast (SequenceDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::SequenceDef_ptr IR::SequenceDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_SequenceDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/SequenceDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_SequenceDef::_nil ());
+    return SequenceDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/SequenceDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (SequenceDef::_nil ());
   if (is_a == 0)
-    return CORBA_SequenceDef::_nil ();
-  return CORBA_SequenceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return SequenceDef::_nil ();
+  return SequenceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_SequenceDef_ptr CORBA_SequenceDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::SequenceDef_ptr IR::SequenceDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_SequenceDef::_nil ();
+    return SequenceDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  SequenceDef_ptr default_proxy = SequenceDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_SequenceDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_SequenceDef_ptr retv = _TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_SequenceDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_SequenceDef_ptr retval = CORBA_SequenceDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_SequenceDef (stub),
-                  CORBA_SequenceDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, SequenceDef (stub), SequenceDef::_nil ());
+  return TAO_IR_SequenceDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_SequenceDef_ptr
-CORBA_SequenceDef::_duplicate (CORBA_SequenceDef_ptr obj)
+IR::SequenceDef_ptr 
+IR::SequenceDef::_duplicate (SequenceDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::ULong CORBA_SequenceDef::bound (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::ULong IR::SequenceDef::bound (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
+  
   CORBA::ULong _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""bound",
+      "_get_bound",
       10,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_bound",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_SequenceDef::bound (
+void IR::SequenceDef::bound (
     CORBA::ULong bound,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""bound",
+      "_set_bound",
       10,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << bound)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << bound)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_bound",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_bound",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::TypeCode_ptr CORBA_SequenceDef::element_type (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::TypeCode_ptr IR::SequenceDef::element_type (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::TypeCode_ptr _tao_retval = 0;
-
-
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""element_type",
+      "_get_element_type",
       17,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_element_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_element_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_element_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_IDLType_ptr CORBA_SequenceDef::element_type_def (
-    CORBA_Environment &ACE_TRY_ENV
+IR::IDLType_ptr IR::SequenceDef::element_type_def (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_IDLType_ptr _tao_retval = CORBA_IDLType::_nil ();
-
-
+  
+  IR::IDLType_ptr _tao_retval = IR::IDLType::_nil ();
+  IR::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""element_type_def",
+      "_get_element_type_def",
       21,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-     CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_element_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_element_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_element_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_SequenceDef::element_type_def (
-    CORBA_IDLType_ptr element_type_def,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::SequenceDef::element_type_def (
+    IR::IDLType_ptr element_type_def,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""element_type_def",
+      "_set_element_type_def",
       21,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << element_type_def)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_element_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << element_type_def)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_element_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_element_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_SequenceDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::SequenceDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/SequenceDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/SequenceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -6962,372 +16050,839 @@ CORBA::Boolean CORBA_SequenceDef::_is_a (const CORBA::Char *value, CORBA_Environ
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_SequenceDef::_interface_repository_id (void) const
+const char* IR::SequenceDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/SequenceDef:1.0";
+}
+
+IR::TAO_IR_SequenceDef_Default_Proxy_Factory::TAO_IR_SequenceDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_SequenceDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_SequenceDef_Default_Proxy_Factory::~TAO_IR_SequenceDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::SequenceDef_ptr
+IR::TAO_IR_SequenceDef_Default_Proxy_Factory::create_proxy (
+    ::IR::SequenceDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_SequenceDef_Proxy_Factory_Adapter::TAO_IR_SequenceDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_SequenceDef_Proxy_Factory_Adapter::~TAO_IR_SequenceDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_SequenceDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_SequenceDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_SequenceDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::SequenceDef_ptr
+IR::TAO_IR_SequenceDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::SequenceDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_SequenceDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_SequenceDef_Smart_Proxy_Base::TAO_IR_SequenceDef_Smart_Proxy_Base (::IR::SequenceDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_SequenceDef_Smart_Proxy_Base::~TAO_IR_SequenceDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_SequenceDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::ULong IR::TAO_IR_SequenceDef_Smart_Proxy_Base::bound  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->bound (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_SequenceDef_Smart_Proxy_Base::bound  (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  return "IDL:omg.org/CORBA/SequenceDef:1.0";
+  this->base_proxy_->bound (
+      bound,
+      ACE_TRY_ENV
+    );
+
 }
 
-static const CORBA::Long _oc_CORBA_SequenceDef[] =
+CORBA::TypeCode_ptr IR::TAO_IR_SequenceDef_Smart_Proxy_Base::element_type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->element_type (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::IDLType_ptr IR::TAO_IR_SequenceDef_Smart_Proxy_Base::element_type_def  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->element_type_def (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_SequenceDef_Smart_Proxy_Base::element_type_def  (
+    IR::IDLType_ptr element_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->element_type_def (
+      element_type_def,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_SequenceDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_SequenceDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_SequenceDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5365), ACE_NTOHL (0x7175656e), ACE_NTOHL (0x63654465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/SequenceDef:1.0
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x65717565), ACE_NTOHL (0x6e636544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/SequenceDef:1.0
   12, ACE_NTOHL (0x53657175), ACE_NTOHL (0x656e6365), ACE_NTOHL (0x44656600),  // name = SequenceDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_SequenceDef (CORBA::tk_objref, sizeof (_oc_CORBA_SequenceDef), (char *) &_oc_CORBA_SequenceDef, 0, sizeof (CORBA_SequenceDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_SequenceDef (CORBA::tk_objref, sizeof (_oc_IR_SequenceDef), (char *) &_oc_IR_SequenceDef, 0, sizeof (IR::SequenceDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_SequenceDef, &_tc_TAO_tc_CORBA_SequenceDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_SequenceDef, &_tc_TAO_tc_IR_SequenceDef)
 TAO_NAMESPACE_END
-CORBA_ArrayDef_ptr CORBA_ArrayDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ArrayDef::_tao_any_destructor (void *x)
+{
+  ArrayDef *tmp = ACE_static_cast (ArrayDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ArrayDef_ptr IR::ArrayDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ArrayDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ArrayDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_ArrayDef::_nil ());
+    return ArrayDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ArrayDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ArrayDef::_nil ());
   if (is_a == 0)
-    return CORBA_ArrayDef::_nil ();
-  return CORBA_ArrayDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return ArrayDef::_nil ();
+  return ArrayDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_ArrayDef_ptr CORBA_ArrayDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::ArrayDef_ptr IR::ArrayDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ArrayDef::_nil ();
+    return ArrayDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  ArrayDef_ptr default_proxy = ArrayDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ArrayDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_ArrayDef_ptr retv = _TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_ArrayDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_ArrayDef_ptr retval = CORBA_ArrayDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_ArrayDef (stub),
-                  CORBA_ArrayDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ArrayDef (stub), ArrayDef::_nil ());
+  return TAO_IR_ArrayDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_ArrayDef_ptr
-CORBA_ArrayDef::_duplicate (CORBA_ArrayDef_ptr obj)
+IR::ArrayDef_ptr 
+IR::ArrayDef::_duplicate (ArrayDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::ULong CORBA_ArrayDef::length (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::ULong IR::ArrayDef::length (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
+  
   CORBA::ULong _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""length",
+      "_get_length",
       11,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-     CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_length",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_length",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_length",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_ArrayDef::length (
+void IR::ArrayDef::length (
     CORBA::ULong length,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""length",
+      "_set_length",
       11,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << length)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_length",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << length)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_length",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_length",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::TypeCode_ptr CORBA_ArrayDef::element_type (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::TypeCode_ptr IR::ArrayDef::element_type (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::TypeCode_ptr _tao_retval = 0;
-
-
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""element_type",
+      "_get_element_type",
       17,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_element_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_element_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_element_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_IDLType_ptr CORBA_ArrayDef::element_type_def (
-    CORBA_Environment &ACE_TRY_ENV
+IR::IDLType_ptr IR::ArrayDef::element_type_def (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_IDLType_ptr _tao_retval = CORBA_IDLType::_nil ();
-
-
+  
+  IR::IDLType_ptr _tao_retval = IR::IDLType::_nil ();
+  IR::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""element_type_def",
+      "_get_element_type_def",
       21,
       istub->orb_core ()
     );
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_element_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_element_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_element_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ArrayDef::element_type_def (
-    CORBA_IDLType_ptr element_type_def,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ArrayDef::element_type_def (
+    IR::IDLType_ptr element_type_def,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""element_type_def",
+      "_set_element_type_def",
       21,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << element_type_def)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_element_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << element_type_def)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_element_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_element_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_ArrayDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::ArrayDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ArrayDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ArrayDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -7335,255 +16890,607 @@ CORBA::Boolean CORBA_ArrayDef::_is_a (const CORBA::Char *value, CORBA_Environmen
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_ArrayDef::_interface_repository_id (void) const
+const char* IR::ArrayDef::_interface_repository_id (void) const
 {
-  return "IDL:omg.org/CORBA/ArrayDef:1.0";
+  return "IDL:omg.org/IR/ArrayDef:1.0";
 }
 
-static const CORBA::Long _oc_CORBA_ArrayDef[] =
+IR::TAO_IR_ArrayDef_Default_Proxy_Factory::TAO_IR_ArrayDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_ArrayDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ArrayDef_Default_Proxy_Factory::~TAO_IR_ArrayDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ArrayDef_ptr
+IR::TAO_IR_ArrayDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ArrayDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ArrayDef_Proxy_Factory_Adapter::TAO_IR_ArrayDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ArrayDef_Proxy_Factory_Adapter::~TAO_IR_ArrayDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ArrayDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ArrayDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ArrayDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::ArrayDef_ptr
+IR::TAO_IR_ArrayDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ArrayDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ArrayDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_ArrayDef_Smart_Proxy_Base::TAO_IR_ArrayDef_Smart_Proxy_Base (::IR::ArrayDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ArrayDef_Smart_Proxy_Base::~TAO_IR_ArrayDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ArrayDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::ULong IR::TAO_IR_ArrayDef_Smart_Proxy_Base::length  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->length (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_ArrayDef_Smart_Proxy_Base::length  (
+    CORBA::ULong length,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->length (
+      length,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr IR::TAO_IR_ArrayDef_Smart_Proxy_Base::element_type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->element_type (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::IDLType_ptr IR::TAO_IR_ArrayDef_Smart_Proxy_Base::element_type_def  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->element_type_def (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_ArrayDef_Smart_Proxy_Base::element_type_def  (
+    IR::IDLType_ptr element_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->element_type_def (
+      element_type_def,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ArrayDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ArrayDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ArrayDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4172), ACE_NTOHL (0x72617944), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ArrayDef:1.0
+  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x72726179), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ArrayDef:1.0
   9, ACE_NTOHL (0x41727261), ACE_NTOHL (0x79446566), ACE_NTOHL (0x0),  // name = ArrayDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ArrayDef (CORBA::tk_objref, sizeof (_oc_CORBA_ArrayDef), (char *) &_oc_CORBA_ArrayDef, 0, sizeof (CORBA_ArrayDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_ArrayDef (CORBA::tk_objref, sizeof (_oc_IR_ArrayDef), (char *) &_oc_IR_ArrayDef, 0, sizeof (IR::ArrayDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ArrayDef, &_tc_TAO_tc_CORBA_ArrayDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ArrayDef, &_tc_TAO_tc_IR_ArrayDef)
 TAO_NAMESPACE_END
-CORBA_ExceptionDef_ptr CORBA_ExceptionDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ExceptionDef::_tao_any_destructor (void *x)
+{
+  ExceptionDef *tmp = ACE_static_cast (ExceptionDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ExceptionDef_ptr IR::ExceptionDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ExceptionDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ExceptionDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_ExceptionDef::_nil ());
+    return ExceptionDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ExceptionDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ExceptionDef::_nil ());
   if (is_a == 0)
-    return CORBA_ExceptionDef::_nil ();
-  return CORBA_ExceptionDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return ExceptionDef::_nil ();
+  return ExceptionDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_ExceptionDef_ptr CORBA_ExceptionDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::ExceptionDef_ptr IR::ExceptionDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ExceptionDef::_nil ();
+    return ExceptionDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  ExceptionDef_ptr default_proxy = ExceptionDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ExceptionDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_ExceptionDef_ptr retv = _TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_ExceptionDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_ExceptionDef_ptr retval = CORBA_ExceptionDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_ExceptionDef (stub),
-                  CORBA_ExceptionDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ExceptionDef (stub), ExceptionDef::_nil ());
+  return TAO_IR_ExceptionDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_ExceptionDef_ptr
-CORBA_ExceptionDef::_duplicate (CORBA_ExceptionDef_ptr obj)
+IR::ExceptionDef_ptr 
+IR::ExceptionDef::_duplicate (ExceptionDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::TypeCode_ptr CORBA_ExceptionDef::type (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::TypeCode_ptr IR::ExceptionDef::type (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::TypeCode_ptr _tao_retval = 0;
-
-
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""type",
+      "_get_type",
       9,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_StructMemberSeq * CORBA_ExceptionDef::members (
-    CORBA_Environment &ACE_TRY_ENV
+IR::StructMemberSeq * IR::ExceptionDef::members (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_StructMemberSeq* _tao_retval = 0;
-
-
+  
+  IR::StructMemberSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_StructMemberSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::StructMemberSeq, _tao_retval);
+  IR::StructMemberSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""members",
+      "_get_members",
       12,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_members",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ExceptionDef::members (
-    const CORBA_StructMemberSeq & members,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ExceptionDef::members (
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""members",
+      "_set_members",
       12,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << members)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_members",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_members",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_ExceptionDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::ExceptionDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ExceptionDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ExceptionDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -7591,438 +17498,1228 @@ CORBA::Boolean CORBA_ExceptionDef::_is_a (const CORBA::Char *value, CORBA_Enviro
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_ExceptionDef::_interface_repository_id (void) const
+const char* IR::ExceptionDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ExceptionDef:1.0";
+}
+
+IR::TAO_IR_ExceptionDef_Default_Proxy_Factory::TAO_IR_ExceptionDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_ExceptionDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ExceptionDef_Default_Proxy_Factory::~TAO_IR_ExceptionDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ExceptionDef_ptr
+IR::TAO_IR_ExceptionDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ExceptionDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ExceptionDef_Proxy_Factory_Adapter::TAO_IR_ExceptionDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ExceptionDef_Proxy_Factory_Adapter::~TAO_IR_ExceptionDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ExceptionDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ExceptionDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ExceptionDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::ExceptionDef_ptr
+IR::TAO_IR_ExceptionDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ExceptionDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ExceptionDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_ExceptionDef_Smart_Proxy_Base::TAO_IR_ExceptionDef_Smart_Proxy_Base (::IR::ExceptionDef_ptr proxy)
+: base_proxy_ (proxy)
 {
-  return "IDL:omg.org/CORBA/ExceptionDef:1.0";
 }
 
-static const CORBA::Long _oc_CORBA_ExceptionDef[] =
+IR::TAO_IR_ExceptionDef_Smart_Proxy_Base::~TAO_IR_ExceptionDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ExceptionDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::TypeCode_ptr IR::TAO_IR_ExceptionDef_Smart_Proxy_Base::type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->type (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::StructMemberSeq * IR::TAO_IR_ExceptionDef_Smart_Proxy_Base::members  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->members (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_ExceptionDef_Smart_Proxy_Base::members  (
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->members (
+      members,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ExceptionDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ExceptionDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ExceptionDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDef:1.0
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDef:1.0
   13, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x0),  // name = ExceptionDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ExceptionDef (CORBA::tk_objref, sizeof (_oc_CORBA_ExceptionDef), (char *) &_oc_CORBA_ExceptionDef, 0, sizeof (CORBA_ExceptionDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_ExceptionDef (CORBA::tk_objref, sizeof (_oc_IR_ExceptionDef), (char *) &_oc_IR_ExceptionDef, 0, sizeof (IR::ExceptionDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDef, &_tc_TAO_tc_CORBA_ExceptionDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDef, &_tc_TAO_tc_IR_ExceptionDef)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_ExceptionDescription[] =
+static const CORBA::Long _oc_IR_ExceptionDescription[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
   21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
   5, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
   5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
   CORBA::tk_TypeCode,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ExceptionDescription (CORBA::tk_struct, sizeof (_oc_CORBA_ExceptionDescription), (char *) &_oc_CORBA_ExceptionDescription, 0, sizeof (CORBA_ExceptionDescription));
+static CORBA::TypeCode _tc_TAO_tc_IR_ExceptionDescription (CORBA::tk_struct, sizeof (_oc_IR_ExceptionDescription), (char *) &_oc_IR_ExceptionDescription, 0, sizeof (IR::ExceptionDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDescription, &_tc_TAO_tc_CORBA_ExceptionDescription)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDescription, &_tc_TAO_tc_IR_ExceptionDescription)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_AttributeMode[] =
+void IR::ExceptionDescription::_tao_any_destructor (void *x)
+{
+  ExceptionDescription *tmp = ACE_static_cast (ExceptionDescription*,x);
+  delete tmp;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EXCEPTIONDEFSEQ_CS_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EXCEPTIONDEFSEQ_CS_
+
+  // The Base_Sequence functions, please see tao/Sequence.h
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::ExceptionDef **tmp = 0;
+    tmp = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::ExceptionDef **old = ACE_reinterpret_cast (IR::ExceptionDef**, this->buffer_);
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        if (!this->release_)
+          tmp[i] = IR::ExceptionDef::_duplicate (old[i]);
+        else
+          tmp[i] = old[i];
+        
+      if (this->release_)
+        delete[] old;
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    IR::ExceptionDef **tmp = ACE_reinterpret_cast (IR::ExceptionDef**, this->buffer_);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ExceptionDef::_nil ();
+    }
+    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  }
+  
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::~_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (void)
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  void
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
+  {
+    IR::ExceptionDef **tmp = ACE_reinterpret_cast (IR::ExceptionDef**, this->buffer_);
+    
+    for (CORBA::ULong i = nl; i < ol; ++i)
+    {
+      CORBA::release (tmp[i]);
+      tmp[i] = IR::ExceptionDef::_nil ();
+    }
+  }
+  void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_downcast (
+      void* target,
+      CORBA_Object *src,
+      CORBA_Environment &ACE_TRY_ENV
+    )
+  {
+    IR::ExceptionDef **tmp = ACE_static_cast (IR::ExceptionDef**, target);
+    *tmp = IR::ExceptionDef::_narrow (src, ACE_TRY_ENV);
+  }
+
+  CORBA_Object*
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_upcast (void *src) const
+  {
+    IR::ExceptionDef **tmp = ACE_static_cast (IR::ExceptionDef**, src);
+    return *tmp;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EXCEPTIONDEFSEQ_CS_)
+#define _IR_EXCEPTIONDEFSEQ_CS_
+
+// *************************************************************
+// IR::ExceptionDefSeq
+// *************************************************************
+
+IR::ExceptionDefSeq::ExceptionDefSeq (void)
+{}
+IR::ExceptionDefSeq::ExceptionDefSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ExceptionDef,IR::ExceptionDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ExceptionDefSeq::ExceptionDefSeq (CORBA::ULong max, CORBA::ULong length, IR::ExceptionDef_ptr *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ExceptionDef,IR::ExceptionDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ExceptionDefSeq::ExceptionDefSeq (const ExceptionDefSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<IR::ExceptionDef,IR::ExceptionDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ExceptionDefSeq::~ExceptionDefSeq (void) // dtor
+{}
+void IR::ExceptionDefSeq::_tao_any_destructor (void *x)
+{
+  ExceptionDefSeq *tmp = ACE_static_cast (ExceptionDefSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ExceptionDefSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x7574654d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ExceptionDefSeq:1.0
+  16, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x53657100),  // name = ExceptionDefSeq
+  CORBA::tk_sequence, // typecode kind
+  76, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_objref, // typecode kind
+    60, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDef:1.0
+      13, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x0),  // name = ExceptionDef
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ExceptionDefSeq (CORBA::tk_alias, sizeof (_oc_IR_ExceptionDefSeq), (char *) &_oc_IR_ExceptionDefSeq, 0, sizeof (IR::ExceptionDefSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDefSeq, &_tc_TAO_tc_IR_ExceptionDefSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_EXCDESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_EXCDESCRIPTIONSEQ_CS_
+
+  void
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::ExceptionDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::ExceptionDescription *old = ACE_reinterpret_cast (IR::ExceptionDescription *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    IR::ExceptionDescription *tmp = ACE_reinterpret_cast (IR::ExceptionDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::~_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EXCDESCRIPTIONSEQ_CS_)
+#define _IR_EXCDESCRIPTIONSEQ_CS_
+
+// *************************************************************
+// IR::ExcDescriptionSeq
+// *************************************************************
+
+IR::ExcDescriptionSeq::ExcDescriptionSeq (void)
+{}
+IR::ExcDescriptionSeq::ExcDescriptionSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ExceptionDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ExcDescriptionSeq::ExcDescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR::ExceptionDescription *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ExceptionDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ExcDescriptionSeq::ExcDescriptionSeq (const ExcDescriptionSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ExceptionDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ExcDescriptionSeq::~ExcDescriptionSeq (void) // dtor
+{}
+void IR::ExcDescriptionSeq::_tao_any_destructor (void *x)
+{
+  ExcDescriptionSeq *tmp = ACE_static_cast (ExcDescriptionSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ExcDescriptionSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+  18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+  CORBA::tk_sequence, // typecode kind
+  668, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    652, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+      21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+      5, // member count
+      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      132, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      3, ACE_NTOHL (0x69640000),  // name = id
+      CORBA::tk_alias, // typecode kind for typedefs
+      140, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+      CORBA::tk_alias, // typecode kind for typedefs
+      140, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+      CORBA::tk_alias, // typecode kind for typedefs
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+        CORBA::tk_string, 
+        0U, // string length
+
+      5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+      CORBA::tk_TypeCode,
+
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ExcDescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_ExcDescriptionSeq), (char *) &_oc_IR_ExcDescriptionSeq, 0, sizeof (IR::ExcDescriptionSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExcDescriptionSeq, &_tc_TAO_tc_IR_ExcDescriptionSeq)
+TAO_NAMESPACE_END
+static const CORBA::Long _oc_IR_AttributeMode[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
   14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
   2, // member count
   12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
   14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_AttributeMode (CORBA::tk_enum, sizeof (_oc_CORBA_AttributeMode), (char *) &_oc_CORBA_AttributeMode, 0, sizeof (CORBA::AttributeMode));
+static CORBA::TypeCode _tc_TAO_tc_IR_AttributeMode (CORBA::tk_enum, sizeof (_oc_IR_AttributeMode), (char *) &_oc_IR_AttributeMode, 0, sizeof (IR::AttributeMode));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeMode, &_tc_TAO_tc_CORBA_AttributeMode)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeMode, &_tc_TAO_tc_IR_AttributeMode)
 TAO_NAMESPACE_END
-CORBA_AttributeDef_ptr CORBA_AttributeDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::AttributeDef::_tao_any_destructor (void *x)
+{
+  AttributeDef *tmp = ACE_static_cast (AttributeDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::AttributeDef_ptr IR::AttributeDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_AttributeDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/AttributeDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_AttributeDef::_nil ());
+    return AttributeDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/AttributeDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (AttributeDef::_nil ());
   if (is_a == 0)
-    return CORBA_AttributeDef::_nil ();
-  return CORBA_AttributeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return AttributeDef::_nil ();
+  return AttributeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_AttributeDef_ptr CORBA_AttributeDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::AttributeDef_ptr IR::AttributeDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_AttributeDef::_nil ();
+    return AttributeDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  AttributeDef_ptr default_proxy = AttributeDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_AttributeDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_AttributeDef_ptr retv = _TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_AttributeDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_AttributeDef_ptr retval = CORBA_AttributeDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_AttributeDef (stub),
-                  CORBA_AttributeDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, AttributeDef (stub), AttributeDef::_nil ());
+  return TAO_IR_AttributeDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_AttributeDef_ptr
-CORBA_AttributeDef::_duplicate (CORBA_AttributeDef_ptr obj)
+IR::AttributeDef_ptr 
+IR::AttributeDef::_duplicate (AttributeDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::TypeCode_ptr CORBA_AttributeDef::type (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::TypeCode_ptr IR::AttributeDef::type (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::TypeCode_ptr _tao_retval = 0;
-
-
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""type",
+      "_get_type",
       9,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_IDLType_ptr CORBA_AttributeDef::type_def (
-    CORBA_Environment &ACE_TRY_ENV
+IR::IDLType_ptr IR::AttributeDef::type_def (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_IDLType_ptr _tao_retval = CORBA_IDLType::_nil ();
-
-
+  
+  IR::IDLType_ptr _tao_retval = IR::IDLType::_nil ();
+  IR::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""type_def",
+      "_get_type_def",
       13,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_AttributeDef::type_def (
-    CORBA_IDLType_ptr type_def,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::AttributeDef::type_def (
+    IR::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""type_def",
+      "_set_type_def",
       13,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << type_def)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << type_def)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::AttributeMode CORBA_AttributeDef::mode (
-    CORBA_Environment &ACE_TRY_ENV
+IR::AttributeMode IR::AttributeDef::mode (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::AttributeMode _tao_retval = (CORBA::AttributeMode)0;
-
-
+  
+  IR::AttributeMode _tao_retval = (IR::AttributeMode)0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""mode",
+      "_get_mode",
       9,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_mode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_mode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_mode",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_AttributeDef::mode (
-    CORBA::AttributeMode mode,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::AttributeDef::mode (
+    IR::AttributeMode mode,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""mode",
+      "_set_mode",
       9,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << mode)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_mode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << mode)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_mode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_mode",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_AttributeDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::AttributeDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/AttributeDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/AttributeDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -8030,62 +18727,257 @@ CORBA::Boolean CORBA_AttributeDef::_is_a (const CORBA::Char *value, CORBA_Enviro
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_AttributeDef::_interface_repository_id (void) const
+const char* IR::AttributeDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/AttributeDef:1.0";
+}
+
+IR::TAO_IR_AttributeDef_Default_Proxy_Factory::TAO_IR_AttributeDef_Default_Proxy_Factory (int register_proxy_factory)
 {
-  return "IDL:omg.org/CORBA/AttributeDef:1.0";
+  if (register_proxy_factory)
+    {
+      TAO_IR_AttributeDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_AttributeDef_Default_Proxy_Factory::~TAO_IR_AttributeDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::AttributeDef_ptr
+IR::TAO_IR_AttributeDef_Default_Proxy_Factory::create_proxy (
+    ::IR::AttributeDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_AttributeDef_Proxy_Factory_Adapter::TAO_IR_AttributeDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_AttributeDef_Proxy_Factory_Adapter::~TAO_IR_AttributeDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_AttributeDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_AttributeDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_AttributeDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::AttributeDef_ptr
+IR::TAO_IR_AttributeDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::AttributeDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_AttributeDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_AttributeDef_Smart_Proxy_Base::TAO_IR_AttributeDef_Smart_Proxy_Base (::IR::AttributeDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_AttributeDef_Smart_Proxy_Base::~TAO_IR_AttributeDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_AttributeDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::TypeCode_ptr IR::TAO_IR_AttributeDef_Smart_Proxy_Base::type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->type (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::IDLType_ptr IR::TAO_IR_AttributeDef_Smart_Proxy_Base::type_def  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->type_def (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_AttributeDef_Smart_Proxy_Base::type_def  (
+    IR::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->type_def (
+      type_def,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::AttributeMode IR::TAO_IR_AttributeDef_Smart_Proxy_Base::mode  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->mode (
+      ACE_TRY_ENV
+    );
+
 }
 
-static const CORBA::Long _oc_CORBA_AttributeDef[] =
+void IR::TAO_IR_AttributeDef_Smart_Proxy_Base::mode  (
+    IR::AttributeMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->mode (
+      mode,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_AttributeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_AttributeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_AttributeDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x75746544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDef:1.0
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDef:1.0
   13, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = AttributeDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_AttributeDef (CORBA::tk_objref, sizeof (_oc_CORBA_AttributeDef), (char *) &_oc_CORBA_AttributeDef, 0, sizeof (CORBA_AttributeDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_AttributeDef (CORBA::tk_objref, sizeof (_oc_IR_AttributeDef), (char *) &_oc_IR_AttributeDef, 0, sizeof (IR::AttributeDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeDef, &_tc_TAO_tc_CORBA_AttributeDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeDef, &_tc_TAO_tc_IR_AttributeDef)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_AttributeDescription[] =
+static const CORBA::Long _oc_IR_AttributeDescription[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x75746544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
   21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-  6, // member count
+  8, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
   5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -8095,77 +18987,241 @@ static const CORBA::Long _oc_CORBA_AttributeDescription[] =
   CORBA::tk_enum, // typecode kind
   104, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x7574654d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
     14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
     2, // member count
     12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
     14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
 
+  15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
+  CORBA::tk_alias, // typecode kind for typedefs
+  748, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+    18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    668, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      652, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+        21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+        5, // member count
+        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        132, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        3, ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        64, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+
+      0U,
+
+
+  15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
+  CORBA::tk_alias, // typecode kind for typedefs
+  748, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+    18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    668, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      652, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+        21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+        5, // member count
+        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        132, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        3, ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        64, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+
+      0U,
+
+
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_AttributeDescription (CORBA::tk_struct, sizeof (_oc_CORBA_AttributeDescription), (char *) &_oc_CORBA_AttributeDescription, 0, sizeof (CORBA_AttributeDescription));
+static CORBA::TypeCode _tc_TAO_tc_IR_AttributeDescription (CORBA::tk_struct, sizeof (_oc_IR_AttributeDescription), (char *) &_oc_IR_AttributeDescription, 0, sizeof (IR::AttributeDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeDescription, &_tc_TAO_tc_CORBA_AttributeDescription)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttributeDescription, &_tc_TAO_tc_IR_AttributeDescription)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_OperationMode[] =
+void IR::AttributeDescription::_tao_any_destructor (void *x)
+{
+  AttributeDescription *tmp = ACE_static_cast (AttributeDescription*,x);
+  delete tmp;
+}
+
+static const CORBA::Long _oc_IR_OperationMode[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
   14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
   2, // member count
   10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
   10, ACE_NTOHL (0x4f505f4f), ACE_NTOHL (0x4e455741), ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_OperationMode (CORBA::tk_enum, sizeof (_oc_CORBA_OperationMode), (char *) &_oc_CORBA_OperationMode, 0, sizeof (CORBA::OperationMode));
+static CORBA::TypeCode _tc_TAO_tc_IR_OperationMode (CORBA::tk_enum, sizeof (_oc_IR_OperationMode), (char *) &_oc_IR_OperationMode, 0, sizeof (IR::OperationMode));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationMode, &_tc_TAO_tc_CORBA_OperationMode)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationMode, &_tc_TAO_tc_IR_OperationMode)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_ParameterMode[] =
+static const CORBA::Long _oc_IR_ParameterMode[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x7465724d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
   14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
   3, // member count
   9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
   10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
   12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ParameterMode (CORBA::tk_enum, sizeof (_oc_CORBA_ParameterMode), (char *) &_oc_CORBA_ParameterMode, 0, sizeof (CORBA::ParameterMode));
+static CORBA::TypeCode _tc_TAO_tc_IR_ParameterMode (CORBA::tk_enum, sizeof (_oc_IR_ParameterMode), (char *) &_oc_IR_ParameterMode, 0, sizeof (IR::ParameterMode));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParameterMode, &_tc_TAO_tc_CORBA_ParameterMode)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParameterMode, &_tc_TAO_tc_IR_ParameterMode)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_ParameterDescription[] =
+static const CORBA::Long _oc_IR_ParameterDescription[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x74657244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
   21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
   4, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
   CORBA::tk_TypeCode,
 
   9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
   CORBA::tk_objref, // typecode kind
-  52, // encapsulation length
+  48, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+    27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
     8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
   5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
   CORBA::tk_enum, // typecode kind
   116, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x7465724d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
     14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
     3, // member count
     9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
@@ -8173,140 +19229,157 @@ static const CORBA::Long _oc_CORBA_ParameterDescription[] =
     12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ParameterDescription (CORBA::tk_struct, sizeof (_oc_CORBA_ParameterDescription), (char *) &_oc_CORBA_ParameterDescription, 0, sizeof (CORBA_ParameterDescription));
+static CORBA::TypeCode _tc_TAO_tc_IR_ParameterDescription (CORBA::tk_struct, sizeof (_oc_IR_ParameterDescription), (char *) &_oc_IR_ParameterDescription, 0, sizeof (IR::ParameterDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParameterDescription, &_tc_TAO_tc_CORBA_ParameterDescription)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParameterDescription, &_tc_TAO_tc_IR_ParameterDescription)
 TAO_NAMESPACE_END
+void IR::ParameterDescription::_tao_any_destructor (void *x)
+{
+  ParameterDescription *tmp = ACE_static_cast (ParameterDescription*,x);
+  delete tmp;
+}
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CS_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_PARDESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_PARDESCRIPTIONSEQ_CS_
 
   void
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_ParameterDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (length);
-
+    IR::ParameterDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_ParameterDescription *old = ACE_reinterpret_cast (CORBA_ParameterDescription *,this->buffer_);
-
+      IR::ParameterDescription *old = ACE_reinterpret_cast (IR::ParameterDescription *,this->buffer_);
+      
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-
+      
       if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (old);
-
+        _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (old);
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-
-    CORBA_ParameterDescription *tmp = ACE_reinterpret_cast (CORBA_ParameterDescription *,this->buffer_);
-
-    _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (tmp);
+    
+    IR::ParameterDescription *tmp = ACE_reinterpret_cast (IR::ParameterDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (tmp);
     this->buffer_ = 0;
-  }
-
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Dtor.
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::~_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-
-
+  
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_PARDESCRIPTIONSEQ_CS_)
-#define _CORBA_PARDESCRIPTIONSEQ_CS_
+#if !defined (_IR_PARDESCRIPTIONSEQ_CS_)
+#define _IR_PARDESCRIPTIONSEQ_CS_
 
 // *************************************************************
-// CORBA_ParDescriptionSeq
+// IR::ParDescriptionSeq
 // *************************************************************
 
-CORBA_ParDescriptionSeq::CORBA_ParDescriptionSeq (void)
+IR::ParDescriptionSeq::ParDescriptionSeq (void)
 {}
-CORBA_ParDescriptionSeq::CORBA_ParDescriptionSeq (CORBA::ULong max) // uses max size
-  :
+IR::ParDescriptionSeq::ParDescriptionSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ParameterDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ParameterDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_ParDescriptionSeq::CORBA_ParDescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA_ParameterDescription *buffer, CORBA::Boolean release)
-  :
+IR::ParDescriptionSeq::ParDescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR::ParameterDescription *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ParameterDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ParameterDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_ParDescriptionSeq::CORBA_ParDescriptionSeq (const CORBA_ParDescriptionSeq &seq) // copy ctor
-  :
+IR::ParDescriptionSeq::ParDescriptionSeq (const ParDescriptionSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ParameterDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ParameterDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_ParDescriptionSeq::~CORBA_ParDescriptionSeq (void) // dtor
+IR::ParDescriptionSeq::~ParDescriptionSeq (void) // dtor
 {}
+void IR::ParDescriptionSeq::_tao_any_destructor (void *x)
+{
+  ParDescriptionSeq *tmp = ACE_static_cast (ParDescriptionSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_ParDescriptionSeq[] =
+static const CORBA::Long _oc_IR_ParDescriptionSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
   18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
   CORBA::tk_sequence, // typecode kind
-  416, // encapsulation length
+  472, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
-    400, // encapsulation length
+    456, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x74657244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+      40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
       21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
       4, // member count
       5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      132, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
         11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
 
       5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
       CORBA::tk_TypeCode,
 
       9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
       CORBA::tk_objref, // typecode kind
-      52, // encapsulation length
+      48, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
         8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
       5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
       CORBA::tk_enum, // typecode kind
       116, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x7465724d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
         14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
         3, // member count
         9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
@@ -8317,1180 +19390,1810 @@ static const CORBA::Long _oc_CORBA_ParDescriptionSeq[] =
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ParDescriptionSeq (CORBA::tk_alias, sizeof (_oc_CORBA_ParDescriptionSeq), (char *) &_oc_CORBA_ParDescriptionSeq, 0, sizeof (CORBA_ParDescriptionSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_ParDescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_ParDescriptionSeq), (char *) &_oc_IR_ParDescriptionSeq, 0, sizeof (IR::ParDescriptionSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParDescriptionSeq, &_tc_TAO_tc_CORBA_ParDescriptionSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ParDescriptionSeq, &_tc_TAO_tc_IR_ParDescriptionSeq)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_ContextIdentifier[] =
+static const CORBA::Long _oc_IR_ContextIdentifier[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496465), ACE_NTOHL (0x6e746966), ACE_NTOHL (0x6965723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
   18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ContextIdentifier (CORBA::tk_alias, sizeof (_oc_CORBA_ContextIdentifier), (char *) &_oc_CORBA_ContextIdentifier, 0, sizeof (CORBA::ContextIdentifier));
+static CORBA::TypeCode _tc_TAO_tc_IR_ContextIdentifier (CORBA::tk_alias, sizeof (_oc_IR_ContextIdentifier), (char *) &_oc_IR_ContextIdentifier, 0, sizeof (IR::ContextIdentifier));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContextIdentifier, &_tc_TAO_tc_CORBA_ContextIdentifier)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContextIdentifier, &_tc_TAO_tc_IR_ContextIdentifier)
 TAO_NAMESPACE_END
 
-#if !defined (_CORBA_CONTEXTIDSEQ_CS_)
-#define _CORBA_CONTEXTIDSEQ_CS_
+#if !defined (_IR_CONTEXTIDSEQ_CS_)
+#define _IR_CONTEXTIDSEQ_CS_
 
 // *************************************************************
-// CORBA_ContextIdSeq
+// IR::ContextIdSeq
 // *************************************************************
 
-CORBA_ContextIdSeq::CORBA_ContextIdSeq (void)
+IR::ContextIdSeq::ContextIdSeq (void)
 {}
-CORBA_ContextIdSeq::CORBA_ContextIdSeq (CORBA::ULong max) // uses max size
-  :
+IR::ContextIdSeq::ContextIdSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_ContextIdSeq::CORBA_ContextIdSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
-  :
+IR::ContextIdSeq::ContextIdSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_ContextIdSeq::CORBA_ContextIdSeq (const CORBA_ContextIdSeq &seq) // copy ctor
-  :
+IR::ContextIdSeq::ContextIdSeq (const ContextIdSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_ContextIdSeq::~CORBA_ContextIdSeq (void) // dtor
+IR::ContextIdSeq::~ContextIdSeq (void) // dtor
 {}
+void IR::ContextIdSeq::_tao_any_destructor (void *x)
+{
+  ContextIdSeq *tmp = ACE_static_cast (ContextIdSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_ContextIdSeq[] =
+static const CORBA::Long _oc_IR_ContextIdSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
   13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
   CORBA::tk_sequence, // typecode kind
-  164, // encapsulation length
+  228, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_alias, // typecode kind for typedefs
-    148, // encapsulation length
+    212, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496465), ACE_NTOHL (0x6e746966), ACE_NTOHL (0x6965723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+      37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
       18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      132, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
         11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string,
-        0U, // string length
-
-
-    0U,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ContextIdSeq (CORBA::tk_alias, sizeof (_oc_CORBA_ContextIdSeq), (char *) &_oc_CORBA_ContextIdSeq, 0, sizeof (CORBA_ContextIdSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContextIdSeq, &_tc_TAO_tc_CORBA_ContextIdSeq)
-TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CS_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CS_
-
-  // The Base_Sequence functions, please see tao/Sequence.h
-  void
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    CORBA_ExceptionDef **tmp = 0;
-    tmp = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (length);
-
-    if (this->buffer_ != 0)
-    {
-      CORBA_ExceptionDef **old = ACE_reinterpret_cast (CORBA_ExceptionDef**, this->buffer_);
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        if (!this->release_)
-          tmp[i] = CORBA_ExceptionDef::_duplicate (old[i]);
-        else
-          tmp[i] = old[i];
-
-      if (this->release_)
-        delete[] old;
-
-    }
-    this->buffer_ = tmp;
-  }
-
-  void
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-    CORBA_ExceptionDef **tmp = ACE_reinterpret_cast (CORBA_ExceptionDef**, this->buffer_);
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = CORBA_ExceptionDef::_nil ();
-    }
-    _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::~_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void)
-  {
-    this->_deallocate_buffer ();
-  }
-
-  void
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
-  {
-    CORBA_ExceptionDef **tmp = ACE_reinterpret_cast (CORBA_ExceptionDef**, this->buffer_);
-
-    for (CORBA::ULong i = nl; i < ol; ++i)
-    {
-      CORBA::release (tmp[i]);
-      tmp[i] = CORBA_ExceptionDef::_nil ();
-    }
-  }
-  void
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_downcast (
-      void* target,
-      CORBA_Object *src,
-      CORBA_Environment &ACE_TRY_ENV
-    )
-  {
-    CORBA_ExceptionDef **tmp = ACE_static_cast (CORBA_ExceptionDef**, target);
-    *tmp = CORBA_ExceptionDef::_narrow (src, ACE_TRY_ENV);
-  }
-
-  CORBA_Object*
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_upcast (void *src) const
-  {
-    CORBA_ExceptionDef **tmp = ACE_static_cast (CORBA_ExceptionDef**, src);
-    return *tmp;
-  }
-
-#endif /* end #if !defined */
-
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-#if !defined (_CORBA_EXCEPTIONDEFSEQ_CS_)
-#define _CORBA_EXCEPTIONDEFSEQ_CS_
-
-// *************************************************************
-// CORBA_ExceptionDefSeq
-// *************************************************************
-
-CORBA_ExceptionDefSeq::CORBA_ExceptionDefSeq (void)
-{}
-CORBA_ExceptionDefSeq::CORBA_ExceptionDefSeq (CORBA::ULong max) // uses max size
-  :
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_ExceptionDef,CORBA_ExceptionDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
- (max)
-{}
-CORBA_ExceptionDefSeq::CORBA_ExceptionDefSeq (CORBA::ULong max, CORBA::ULong length, CORBA_ExceptionDef_ptr *buffer, CORBA::Boolean release)
-  :
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_ExceptionDef,CORBA_ExceptionDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
- (max, length, buffer, release)
-{}
-CORBA_ExceptionDefSeq::CORBA_ExceptionDefSeq (const CORBA_ExceptionDefSeq &seq) // copy ctor
-  :
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Object_Sequence<CORBA_ExceptionDef,CORBA_ExceptionDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
- (seq)
-{}
-CORBA_ExceptionDefSeq::~CORBA_ExceptionDefSeq (void) // dtor
-{}
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
 
 
-#endif /* end #if !defined */
-
-static const CORBA::Long _oc_CORBA_ExceptionDefSeq[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ExceptionDefSeq:1.0
-  16, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x53657100),  // name = ExceptionDefSeq
-  CORBA::tk_sequence, // typecode kind
-  80, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_objref, // typecode kind
-    64, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDef:1.0
-      13, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x0),  // name = ExceptionDef
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ExceptionDefSeq (CORBA::tk_alias, sizeof (_oc_CORBA_ExceptionDefSeq), (char *) &_oc_CORBA_ExceptionDefSeq, 0, sizeof (CORBA_ExceptionDefSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_ContextIdSeq (CORBA::tk_alias, sizeof (_oc_IR_ContextIdSeq), (char *) &_oc_IR_ContextIdSeq, 0, sizeof (IR::ContextIdSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExceptionDefSeq, &_tc_TAO_tc_CORBA_ExceptionDefSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ContextIdSeq, &_tc_TAO_tc_IR_ContextIdSeq)
 TAO_NAMESPACE_END
-
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CS_
-
-  void
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_allocate_buffer (CORBA::ULong length)
-  {
-    CORBA_ExceptionDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (length);
-
-    if (this->buffer_ != 0)
-    {
-      CORBA_ExceptionDescription *old = ACE_reinterpret_cast (CORBA_ExceptionDescription *,this->buffer_);
-
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-        tmp[i] = old[i];
-
-      if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (old);
-
-    }
-    this->buffer_ = tmp;
-  }
-
-  void
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_deallocate_buffer (void)
-  {
-    if (this->buffer_ == 0 || this->release_ == 0)
-      return;
-
-    CORBA_ExceptionDescription *tmp = ACE_reinterpret_cast (CORBA_ExceptionDescription *,this->buffer_);
-
-    _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (tmp);
-    this->buffer_ = 0;
-  }
-
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Dtor.
-  {
-    this->_deallocate_buffer ();
-  }
-
-
-#endif /* end #if !defined */
-
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-#if !defined (_CORBA_EXCDESCRIPTIONSEQ_CS_)
-#define _CORBA_EXCDESCRIPTIONSEQ_CS_
-
-// *************************************************************
-// CORBA_ExcDescriptionSeq
-// *************************************************************
-
-CORBA_ExcDescriptionSeq::CORBA_ExcDescriptionSeq (void)
-{}
-CORBA_ExcDescriptionSeq::CORBA_ExcDescriptionSeq (CORBA::ULong max) // uses max size
-  :
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ExceptionDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
- (max)
-{}
-CORBA_ExcDescriptionSeq::CORBA_ExcDescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA_ExceptionDescription *buffer, CORBA::Boolean release)
-  :
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ExceptionDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
- (max, length, buffer, release)
-{}
-CORBA_ExcDescriptionSeq::CORBA_ExcDescriptionSeq (const CORBA_ExcDescriptionSeq &seq) // copy ctor
-  :
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ExceptionDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
- (seq)
-{}
-CORBA_ExcDescriptionSeq::~CORBA_ExcDescriptionSeq (void) // dtor
-{}
-
-
-#endif /* end #if !defined */
-
-static const CORBA::Long _oc_CORBA_ExcDescriptionSeq[] =
+void IR::OperationDef::_tao_any_destructor (void *x)
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
-  18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
-  CORBA::tk_sequence, // typecode kind
-  476, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    CORBA::tk_struct, // typecode kind
-    460, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
-      21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
-      5, // member count
-      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
-        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string,
-        0U, // string length
-
-      3, ACE_NTOHL (0x69640000),  // name = id
-      CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
-
-      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-      CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
-
-      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-      CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
-        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string,
-        0U, // string length
-
-      5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-      CORBA::tk_TypeCode,
-
-
-    0U,
+  OperationDef *tmp = ACE_static_cast (OperationDef*,x);
+  CORBA::release (tmp);
+}
 
-};
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ExcDescriptionSeq (CORBA::tk_alias, sizeof (_oc_CORBA_ExcDescriptionSeq), (char *) &_oc_CORBA_ExcDescriptionSeq, 0, sizeof (CORBA_ExcDescriptionSeq));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ExcDescriptionSeq, &_tc_TAO_tc_CORBA_ExcDescriptionSeq)
-TAO_NAMESPACE_END
-CORBA_OperationDef_ptr CORBA_OperationDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+IR::OperationDef_ptr IR::OperationDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_OperationDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/OperationDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_OperationDef::_nil ());
+    return OperationDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/OperationDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (OperationDef::_nil ());
   if (is_a == 0)
-    return CORBA_OperationDef::_nil ();
-  return CORBA_OperationDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return OperationDef::_nil ();
+  return OperationDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_OperationDef_ptr CORBA_OperationDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::OperationDef_ptr IR::OperationDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_OperationDef::_nil ();
+    return OperationDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  OperationDef_ptr default_proxy = OperationDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_OperationDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_OperationDef_ptr retv = _TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_OperationDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_OperationDef_ptr retval = CORBA_OperationDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_OperationDef (stub),
-                  CORBA_OperationDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, OperationDef (stub), OperationDef::_nil ());
+  return TAO_IR_OperationDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_OperationDef_ptr
-CORBA_OperationDef::_duplicate (CORBA_OperationDef_ptr obj)
+IR::OperationDef_ptr 
+IR::OperationDef::_duplicate (OperationDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::TypeCode_ptr CORBA_OperationDef::result (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::TypeCode_ptr IR::OperationDef::result (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::TypeCode_ptr _tao_retval = 0;
-
-
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""result",
+      "_get_result",
       11,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_result",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_result",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_result",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_IDLType_ptr CORBA_OperationDef::result_def (
-    CORBA_Environment &ACE_TRY_ENV
+IR::IDLType_ptr IR::OperationDef::result_def (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_IDLType_ptr _tao_retval = CORBA_IDLType::_nil ();
-
-
+  
+  IR::IDLType_ptr _tao_retval = IR::IDLType::_nil ();
+  IR::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""result_def",
+      "_get_result_def",
       15,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_result_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_result_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_result_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_OperationDef::result_def (
-    CORBA_IDLType_ptr result_def,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::OperationDef::result_def (
+    IR::IDLType_ptr result_def,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""result_def",
+      "_set_result_def",
       15,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << result_def)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_result_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << result_def)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_result_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_result_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA_ParDescriptionSeq * CORBA_OperationDef::params (
-    CORBA_Environment &ACE_TRY_ENV
+IR::ParDescriptionSeq * IR::OperationDef::params (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_ParDescriptionSeq* _tao_retval = 0;
-
-
+  
+  IR::ParDescriptionSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_ParDescriptionSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ParDescriptionSeq, _tao_retval);
+  IR::ParDescriptionSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""params",
+      "_get_params",
       11,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_params",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_params",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_params",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_OperationDef::params (
-    const CORBA_ParDescriptionSeq & params,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::OperationDef::params (
+    const IR::ParDescriptionSeq & params,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""params",
+      "_set_params",
       11,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << params)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_params",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << params)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_params",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_params",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::OperationMode CORBA_OperationDef::mode (
-    CORBA_Environment &ACE_TRY_ENV
+IR::OperationMode IR::OperationDef::mode (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::OperationMode _tao_retval = (CORBA::OperationMode)0;
-
-
+  
+  IR::OperationMode _tao_retval = (IR::OperationMode)0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""mode",
+      "_get_mode",
       9,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_mode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_mode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_mode",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_OperationDef::mode (
-    CORBA::OperationMode mode,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::OperationDef::mode (
+    IR::OperationMode mode,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""mode",
+      "_set_mode",
       9,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << mode)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_mode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << mode)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_mode",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_mode",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA_ContextIdSeq * CORBA_OperationDef::contexts (
-    CORBA_Environment &ACE_TRY_ENV
+IR::ContextIdSeq * IR::OperationDef::contexts (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_ContextIdSeq* _tao_retval = 0;
-
-
+  
+  IR::ContextIdSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_ContextIdSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ContextIdSeq, _tao_retval);
+  IR::ContextIdSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""contexts",
+      "_get_contexts",
       13,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_contexts",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_contexts",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_contexts",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_OperationDef::contexts (
-    const CORBA_ContextIdSeq & contexts,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::OperationDef::contexts (
+    const IR::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""contexts",
+      "_set_contexts",
       13,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
-    CORBA::Short flag = 131;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_contexts",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << contexts)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_contexts",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_contexts",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << contexts)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK;
+IR::ExceptionDefSeq * IR::OperationDef::exceptions (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ExceptionDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ExceptionDefSeq, _tao_retval);
+  IR::ExceptionDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_exceptions",
+      15,
+      istub->orb_core ()
+    );
 
-    }
-    break;
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  }
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_exceptions",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_exceptions",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_exceptions",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_ExceptionDefSeq * CORBA_OperationDef::exceptions (
-    CORBA_Environment &ACE_TRY_ENV
+void IR::OperationDef::exceptions (
+    const IR::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-  CORBA_ExceptionDefSeq* _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW (CORBA::INTERNAL ());
 
-  ACE_NEW_RETURN (_tao_retval, CORBA_ExceptionDefSeq, _tao_retval);
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""exceptions",
+      "_set_exceptions",
       15,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_exceptions",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << exceptions)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_exceptions",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_exceptions",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+}
+
+CORBA::Boolean IR::OperationDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/OperationDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+const char* IR::OperationDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/OperationDef:1.0";
+}
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+IR::TAO_IR_OperationDef_Default_Proxy_Factory::TAO_IR_OperationDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+      TAO_IR_OperationDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_OperationDef_Default_Proxy_Factory::~TAO_IR_OperationDef_Default_Proxy_Factory (void)
+{
+}
 
+IR::OperationDef_ptr
+IR::TAO_IR_OperationDef_Default_Proxy_Factory::create_proxy (
+    ::IR::OperationDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_OperationDef_Proxy_Factory_Adapter::TAO_IR_OperationDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_OperationDef_Proxy_Factory_Adapter::~TAO_IR_OperationDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_OperationDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_OperationDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_OperationDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
     }
-    break;
+return 0;
+}
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+IR::OperationDef_ptr
+IR::TAO_IR_OperationDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::OperationDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_OperationDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_OperationDef_Smart_Proxy_Base::TAO_IR_OperationDef_Smart_Proxy_Base (::IR::OperationDef_ptr proxy)
+: base_proxy_ (proxy)
+{
 }
 
-void CORBA_OperationDef::exceptions (
-    const CORBA_ExceptionDefSeq & exceptions,
-    CORBA_Environment &ACE_TRY_ENV
+IR::TAO_IR_OperationDef_Smart_Proxy_Base::~TAO_IR_OperationDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_OperationDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::TypeCode_ptr IR::TAO_IR_OperationDef_Smart_Proxy_Base::result  (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  return this->base_proxy_->result (
+      ACE_TRY_ENV
+    );
 
+}
 
+IR::IDLType_ptr IR::TAO_IR_OperationDef_Smart_Proxy_Base::result_def  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->result_def (
+      ACE_TRY_ENV
+    );
 
+}
 
-  TAO_Stub *istub = this->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
+void IR::TAO_IR_OperationDef_Smart_Proxy_Base::result_def  (
+    IR::IDLType_ptr result_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->result_def (
+      result_def,
+      ACE_TRY_ENV
+    );
 
+}
 
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_""exceptions",
-      15,
-      istub->orb_core ()
+IR::ParDescriptionSeq * IR::TAO_IR_OperationDef_Smart_Proxy_Base::params  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->params (
+      ACE_TRY_ENV
     );
 
+}
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
+void IR::TAO_IR_OperationDef_Smart_Proxy_Base::params  (
+    const IR::ParDescriptionSeq & params,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->params (
+      params,
+      ACE_TRY_ENV
+    );
 
-    CORBA::Short flag = 131;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
+IR::OperationMode IR::TAO_IR_OperationDef_Smart_Proxy_Base::mode  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->mode (
+      ACE_TRY_ENV
+    );
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << exceptions)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK;
+void IR::TAO_IR_OperationDef_Smart_Proxy_Base::mode  (
+    IR::OperationMode mode,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->mode (
+      mode,
+      ACE_TRY_ENV
+    );
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+}
 
-    }
-    break;
+IR::ContextIdSeq * IR::TAO_IR_OperationDef_Smart_Proxy_Base::contexts  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->contexts (
+      ACE_TRY_ENV
+    );
 
-  }
+}
+
+void IR::TAO_IR_OperationDef_Smart_Proxy_Base::contexts  (
+    const IR::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->contexts (
+      contexts,
+      ACE_TRY_ENV
+    );
 
 }
 
-CORBA::Boolean CORBA_OperationDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+IR::ExceptionDefSeq * IR::TAO_IR_OperationDef_Smart_Proxy_Base::exceptions  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/OperationDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+  return this->base_proxy_->exceptions (
+      ACE_TRY_ENV
+    );
+
 }
 
-const char* CORBA_OperationDef::_interface_repository_id (void) const
+void IR::TAO_IR_OperationDef_Smart_Proxy_Base::exceptions  (
+    const IR::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  return "IDL:omg.org/CORBA/OperationDef:1.0";
+  this->base_proxy_->exceptions (
+      exceptions,
+      ACE_TRY_ENV
+    );
+
 }
 
-static const CORBA::Long _oc_CORBA_OperationDef[] =
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_OperationDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_OperationDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_OperationDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDef:1.0
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDef:1.0
   13, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446566), ACE_NTOHL (0x0),  // name = OperationDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_OperationDef (CORBA::tk_objref, sizeof (_oc_CORBA_OperationDef), (char *) &_oc_CORBA_OperationDef, 0, sizeof (CORBA_OperationDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_OperationDef (CORBA::tk_objref, sizeof (_oc_IR_OperationDef), (char *) &_oc_IR_OperationDef, 0, sizeof (IR::OperationDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationDef, &_tc_TAO_tc_CORBA_OperationDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationDef, &_tc_TAO_tc_IR_OperationDef)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_OperationDescription[] =
+static const CORBA::Long _oc_IR_OperationDescription[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDescription:1.0
+  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
   21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
   9, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
   7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
@@ -9500,7 +21203,7 @@ static const CORBA::Long _oc_CORBA_OperationDescription[] =
   CORBA::tk_enum, // typecode kind
   100, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
     14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
     2, // member count
     10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
@@ -9508,25 +21211,31 @@ static const CORBA::Long _oc_CORBA_OperationDescription[] =
 
   9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
   CORBA::tk_alias, // typecode kind for typedefs
-  236, // encapsulation length
+  296, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
     13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
     CORBA::tk_sequence, // typecode kind
-    164, // encapsulation length
+    228, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_alias, // typecode kind for typedefs
-      148, // encapsulation length
+      212, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496465), ACE_NTOHL (0x6e746966), ACE_NTOHL (0x6965723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
         18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        132, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
           11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
 
 
       0U,
@@ -9534,43 +21243,49 @@ static const CORBA::Long _oc_CORBA_OperationDescription[] =
 
   11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
   CORBA::tk_alias, // typecode kind for typedefs
-  496, // encapsulation length
+  552, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
     18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
     CORBA::tk_sequence, // typecode kind
-    416, // encapsulation length
+    472, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_struct, // typecode kind
-      400, // encapsulation length
+      456, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x74657244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
         21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
         4, // member count
         5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        132, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
           11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
 
         5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
         CORBA::tk_TypeCode,
 
         9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
         CORBA::tk_objref, // typecode kind
-        52, // encapsulation length
+        48, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+          27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
           8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
         5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
         CORBA::tk_enum, // typecode kind
         116, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x7465724d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
           14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
           3, // member count
           9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
@@ -9583,53 +21298,71 @@ static const CORBA::Long _oc_CORBA_OperationDescription[] =
 
   11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
   CORBA::tk_alias, // typecode kind for typedefs
-  556, // encapsulation length
+  748, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
     18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
     CORBA::tk_sequence, // typecode kind
-    476, // encapsulation length
+    668, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_struct, // typecode kind
-      460, // encapsulation length
+      652, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
         21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
         5, // member count
         5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        132, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
           11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
 
         3, ACE_NTOHL (0x69640000),  // name = id
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        64, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
           12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string,
+          CORBA::tk_string, 
           0U, // string length
 
         5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -9640,217 +21373,257 @@ static const CORBA::Long _oc_CORBA_OperationDescription[] =
 
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_OperationDescription (CORBA::tk_struct, sizeof (_oc_CORBA_OperationDescription), (char *) &_oc_CORBA_OperationDescription, 0, sizeof (CORBA_OperationDescription));
+static CORBA::TypeCode _tc_TAO_tc_IR_OperationDescription (CORBA::tk_struct, sizeof (_oc_IR_OperationDescription), (char *) &_oc_IR_OperationDescription, 0, sizeof (IR::OperationDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationDescription, &_tc_TAO_tc_CORBA_OperationDescription)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OperationDescription, &_tc_TAO_tc_IR_OperationDescription)
 TAO_NAMESPACE_END
+void IR::OperationDescription::_tao_any_destructor (void *x)
+{
+  OperationDescription *tmp = ACE_static_cast (OperationDescription*,x);
+  delete tmp;
+}
+
 
-#if !defined (_CORBA_REPOSITORYIDSEQ_CS_)
-#define _CORBA_REPOSITORYIDSEQ_CS_
+#if !defined (_IR_REPOSITORYIDSEQ_CS_)
+#define _IR_REPOSITORYIDSEQ_CS_
 
 // *************************************************************
-// CORBA_RepositoryIdSeq
+// IR::RepositoryIdSeq
 // *************************************************************
 
-CORBA_RepositoryIdSeq::CORBA_RepositoryIdSeq (void)
+IR::RepositoryIdSeq::RepositoryIdSeq (void)
 {}
-CORBA_RepositoryIdSeq::CORBA_RepositoryIdSeq (CORBA::ULong max) // uses max size
-  :
+IR::RepositoryIdSeq::RepositoryIdSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_RepositoryIdSeq::CORBA_RepositoryIdSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
-  :
+IR::RepositoryIdSeq::RepositoryIdSeq (CORBA::ULong max, CORBA::ULong length, char * *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_RepositoryIdSeq::CORBA_RepositoryIdSeq (const CORBA_RepositoryIdSeq &seq) // copy ctor
-  :
+IR::RepositoryIdSeq::RepositoryIdSeq (const RepositoryIdSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   TAO_Unbounded_String_Sequence
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
   TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_RepositoryIdSeq::~CORBA_RepositoryIdSeq (void) // dtor
+IR::RepositoryIdSeq::~RepositoryIdSeq (void) // dtor
 {}
+void IR::RepositoryIdSeq::_tao_any_destructor (void *x)
+{
+  RepositoryIdSeq *tmp = ACE_static_cast (RepositoryIdSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_RepositoryIdSeq[] =
+static const CORBA::Long _oc_IR_RepositoryIdSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49645365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
   16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
   CORBA::tk_sequence, // typecode kind
-  88, // encapsulation length
+  156, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_alias, // typecode kind for typedefs
-    72, // encapsulation length
+    140, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
       13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-      CORBA::tk_string,
-      0U, // string length
+      CORBA::tk_alias, // typecode kind for typedefs
+      72, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_string, 
+        0U, // string length
+
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_RepositoryIdSeq (CORBA::tk_alias, sizeof (_oc_CORBA_RepositoryIdSeq), (char *) &_oc_CORBA_RepositoryIdSeq, 0, sizeof (CORBA_RepositoryIdSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_RepositoryIdSeq (CORBA::tk_alias, sizeof (_oc_IR_RepositoryIdSeq), (char *) &_oc_IR_RepositoryIdSeq, 0, sizeof (IR::RepositoryIdSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryIdSeq, &_tc_TAO_tc_CORBA_RepositoryIdSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_RepositoryIdSeq, &_tc_TAO_tc_IR_RepositoryIdSeq)
 TAO_NAMESPACE_END
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CS_
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_OPDESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_OPDESCRIPTIONSEQ_CS_
 
   void
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_OperationDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (length);
-
+    IR::OperationDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_OperationDescription *old = ACE_reinterpret_cast (CORBA_OperationDescription *,this->buffer_);
-
+      IR::OperationDescription *old = ACE_reinterpret_cast (IR::OperationDescription *,this->buffer_);
+      
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-
+      
       if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (old);
-
+        _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (old);
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-
-    CORBA_OperationDescription *tmp = ACE_reinterpret_cast (CORBA_OperationDescription *,this->buffer_);
-
-    _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (tmp);
+    
+    IR::OperationDescription *tmp = ACE_reinterpret_cast (IR::OperationDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (tmp);
     this->buffer_ = 0;
-  }
-
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Dtor.
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::~_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-
-
+  
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_OPDESCRIPTIONSEQ_CS_)
-#define _CORBA_OPDESCRIPTIONSEQ_CS_
+#if !defined (_IR_OPDESCRIPTIONSEQ_CS_)
+#define _IR_OPDESCRIPTIONSEQ_CS_
 
 // *************************************************************
-// CORBA_OpDescriptionSeq
+// IR::OpDescriptionSeq
 // *************************************************************
 
-CORBA_OpDescriptionSeq::CORBA_OpDescriptionSeq (void)
+IR::OpDescriptionSeq::OpDescriptionSeq (void)
 {}
-CORBA_OpDescriptionSeq::CORBA_OpDescriptionSeq (CORBA::ULong max) // uses max size
-  :
+IR::OpDescriptionSeq::OpDescriptionSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_OperationDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::OperationDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_OpDescriptionSeq::CORBA_OpDescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA_OperationDescription *buffer, CORBA::Boolean release)
-  :
+IR::OpDescriptionSeq::OpDescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR::OperationDescription *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_OperationDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::OperationDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_OpDescriptionSeq::CORBA_OpDescriptionSeq (const CORBA_OpDescriptionSeq &seq) // copy ctor
-  :
+IR::OpDescriptionSeq::OpDescriptionSeq (const OpDescriptionSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_OperationDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::OperationDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_OpDescriptionSeq::~CORBA_OpDescriptionSeq (void) // dtor
+IR::OpDescriptionSeq::~OpDescriptionSeq (void) // dtor
 {}
+void IR::OpDescriptionSeq::_tao_any_destructor (void *x)
+{
+  OpDescriptionSeq *tmp = ACE_static_cast (OpDescriptionSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_OpDescriptionSeq[] =
+static const CORBA::Long _oc_IR_OpDescriptionSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OpDescriptionSeq:1.0
+  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OpDescriptionSeq:1.0
   17, ACE_NTOHL (0x4f704465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x0),  // name = OpDescriptionSeq
   CORBA::tk_sequence, // typecode kind
-  1956, // encapsulation length
+  2456, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
-    1940, // encapsulation length
+    2440, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDescription:1.0
+      40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
       21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
       9, // member count
       5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      132, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
         11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
 
       3, ACE_NTOHL (0x69640000),  // name = id
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      64, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
         12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string,
+        CORBA::tk_string, 
         0U, // string length
 
       7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
@@ -9860,7 +21633,7 @@ static const CORBA::Long _oc_CORBA_OpDescriptionSeq[] =
       CORBA::tk_enum, // typecode kind
       100, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
         14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
         2, // member count
         10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
@@ -9868,25 +21641,31 @@ static const CORBA::Long _oc_CORBA_OpDescriptionSeq[] =
 
       9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
       CORBA::tk_alias, // typecode kind for typedefs
-      236, // encapsulation length
+      296, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
         13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
         CORBA::tk_sequence, // typecode kind
-        164, // encapsulation length
+        228, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
           CORBA::tk_alias, // typecode kind for typedefs
-          148, // encapsulation length
+          212, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
-            40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496465), ACE_NTOHL (0x6e746966), ACE_NTOHL (0x6965723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+            37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
             18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
             CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
+            132, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
               11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string,
-              0U, // string length
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
 
 
           0U,
@@ -9894,43 +21673,49 @@ static const CORBA::Long _oc_CORBA_OpDescriptionSeq[] =
 
       11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
       CORBA::tk_alias, // typecode kind for typedefs
-      496, // encapsulation length
+      552, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
         18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
         CORBA::tk_sequence, // typecode kind
-        416, // encapsulation length
+        472, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
           CORBA::tk_struct, // typecode kind
-          400, // encapsulation length
+          456, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
-            43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x74657244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+            40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
             21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
             4, // member count
             5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
             CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
+            132, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
               11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string,
-              0U, // string length
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
 
             5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
             CORBA::tk_TypeCode,
 
             9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
             CORBA::tk_objref, // typecode kind
-            52, // encapsulation length
+            48, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+              27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
               8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
             5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
             CORBA::tk_enum, // typecode kind
             116, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x7465724d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+              33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
               14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
               3, // member count
               9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
@@ -9943,53 +21728,71 @@ static const CORBA::Long _oc_CORBA_OpDescriptionSeq[] =
 
       11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
       CORBA::tk_alias, // typecode kind for typedefs
-      556, // encapsulation length
+      748, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
         18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
         CORBA::tk_sequence, // typecode kind
-        476, // encapsulation length
+        668, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
           CORBA::tk_struct, // typecode kind
-          460, // encapsulation length
+          652, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
-            43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+            40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
             21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
             5, // member count
             5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
             CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
+            132, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
               11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-              CORBA::tk_string,
-              0U, // string length
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
 
             3, ACE_NTOHL (0x69640000),  // name = id
             CORBA::tk_alias, // typecode kind for typedefs
-            72, // encapsulation length
+            140, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
               13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-              CORBA::tk_string,
-              0U, // string length
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
 
             11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
             CORBA::tk_alias, // typecode kind for typedefs
-            72, // encapsulation length
+            140, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
               13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-              CORBA::tk_string,
-              0U, // string length
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
 
             8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
             CORBA::tk_alias, // typecode kind for typedefs
-            68, // encapsulation length
+            64, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+              31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
               12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-              CORBA::tk_string,
+              CORBA::tk_string, 
               0U, // string length
 
             5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -10003,150 +21806,173 @@ static const CORBA::Long _oc_CORBA_OpDescriptionSeq[] =
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_OpDescriptionSeq (CORBA::tk_alias, sizeof (_oc_CORBA_OpDescriptionSeq), (char *) &_oc_CORBA_OpDescriptionSeq, 0, sizeof (CORBA_OpDescriptionSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_OpDescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_OpDescriptionSeq), (char *) &_oc_IR_OpDescriptionSeq, 0, sizeof (IR::OpDescriptionSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OpDescriptionSeq, &_tc_TAO_tc_CORBA_OpDescriptionSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_OpDescriptionSeq, &_tc_TAO_tc_IR_OpDescriptionSeq)
 TAO_NAMESPACE_END
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CS_
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_ATTRDESCRIPTIONSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_ATTRDESCRIPTIONSEQ_CS_
 
   void
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_AttributeDescription* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (length);
-
+    IR::AttributeDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_AttributeDescription *old = ACE_reinterpret_cast (CORBA_AttributeDescription *,this->buffer_);
-
+      IR::AttributeDescription *old = ACE_reinterpret_cast (IR::AttributeDescription *,this->buffer_);
+      
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-
+      
       if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (old);
-
+        _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (old);
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-
-    CORBA_AttributeDescription *tmp = ACE_reinterpret_cast (CORBA_AttributeDescription *,this->buffer_);
-
-    _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (tmp);
+    
+    IR::AttributeDescription *tmp = ACE_reinterpret_cast (IR::AttributeDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (tmp);
     this->buffer_ = 0;
-  }
-
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::~_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Dtor.
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::~_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-
-
+  
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_ATTRDESCRIPTIONSEQ_CS_)
-#define _CORBA_ATTRDESCRIPTIONSEQ_CS_
+#if !defined (_IR_ATTRDESCRIPTIONSEQ_CS_)
+#define _IR_ATTRDESCRIPTIONSEQ_CS_
 
 // *************************************************************
-// CORBA_AttrDescriptionSeq
+// IR::AttrDescriptionSeq
 // *************************************************************
 
-CORBA_AttrDescriptionSeq::CORBA_AttrDescriptionSeq (void)
+IR::AttrDescriptionSeq::AttrDescriptionSeq (void)
 {}
-CORBA_AttrDescriptionSeq::CORBA_AttrDescriptionSeq (CORBA::ULong max) // uses max size
-  :
+IR::AttrDescriptionSeq::AttrDescriptionSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_AttributeDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::AttributeDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_AttrDescriptionSeq::CORBA_AttrDescriptionSeq (CORBA::ULong max, CORBA::ULong length, CORBA_AttributeDescription *buffer, CORBA::Boolean release)
-  :
+IR::AttrDescriptionSeq::AttrDescriptionSeq (CORBA::ULong max, CORBA::ULong length, IR::AttributeDescription *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_AttributeDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::AttributeDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_AttrDescriptionSeq::CORBA_AttrDescriptionSeq (const CORBA_AttrDescriptionSeq &seq) // copy ctor
-  :
+IR::AttrDescriptionSeq::AttrDescriptionSeq (const AttrDescriptionSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_AttributeDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::AttributeDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_AttrDescriptionSeq::~CORBA_AttrDescriptionSeq (void) // dtor
+IR::AttrDescriptionSeq::~AttrDescriptionSeq (void) // dtor
 {}
+void IR::AttrDescriptionSeq::_tao_any_destructor (void *x)
+{
+  AttrDescriptionSeq *tmp = ACE_static_cast (AttrDescriptionSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_AttrDescriptionSeq[] =
+static const CORBA::Long _oc_IR_AttrDescriptionSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
+  38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
   19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
   CORBA::tk_sequence, // typecode kind
-  600, // encapsulation length
+  2344, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
-    584, // encapsulation length
+    2328, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x75746544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+      40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
       21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-      6, // member count
+      8, // member count
       5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      132, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
         11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
 
       3, ACE_NTOHL (0x69640000),  // name = id
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      64, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
         12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string,
+        CORBA::tk_string, 
         0U, // string length
 
       5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -10156,206 +21982,942 @@ static const CORBA::Long _oc_CORBA_AttrDescriptionSeq[] =
       CORBA::tk_enum, // typecode kind
       104, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x7574654d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
         14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
         2, // member count
         12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
         14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
 
+      15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
+      CORBA::tk_alias, // typecode kind for typedefs
+      748, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+        18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+        CORBA::tk_sequence, // typecode kind
+        668, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          CORBA::tk_struct, // typecode kind
+          652, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+            21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+            5, // member count
+            5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+            CORBA::tk_alias, // typecode kind for typedefs
+            132, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+              11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+
+            3, ACE_NTOHL (0x69640000),  // name = id
+            CORBA::tk_alias, // typecode kind for typedefs
+            140, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+
+            11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+            CORBA::tk_alias, // typecode kind for typedefs
+            140, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+
+            8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+            CORBA::tk_alias, // typecode kind for typedefs
+            64, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+              12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+              CORBA::tk_string, 
+              0U, // string length
+
+            5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+            CORBA::tk_TypeCode,
+
+
+          0U,
+
+
+      15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
+      CORBA::tk_alias, // typecode kind for typedefs
+      748, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+        18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+        CORBA::tk_sequence, // typecode kind
+        668, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          CORBA::tk_struct, // typecode kind
+          652, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+            21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+            5, // member count
+            5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+            CORBA::tk_alias, // typecode kind for typedefs
+            132, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+              11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+              CORBA::tk_alias, // typecode kind for typedefs
+              68, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_string, 
+                0U, // string length
+
+
+            3, ACE_NTOHL (0x69640000),  // name = id
+            CORBA::tk_alias, // typecode kind for typedefs
+            140, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+
+            11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+            CORBA::tk_alias, // typecode kind for typedefs
+            140, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+              13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+              CORBA::tk_alias, // typecode kind for typedefs
+              72, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_string, 
+                0U, // string length
+
+
+            8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+            CORBA::tk_alias, // typecode kind for typedefs
+            64, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+              12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+              CORBA::tk_string, 
+              0U, // string length
+
+            5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+            CORBA::tk_TypeCode,
+
+
+          0U,
+
+
 
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_AttrDescriptionSeq (CORBA::tk_alias, sizeof (_oc_CORBA_AttrDescriptionSeq), (char *) &_oc_CORBA_AttrDescriptionSeq, 0, sizeof (CORBA_AttrDescriptionSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_AttrDescriptionSeq (CORBA::tk_alias, sizeof (_oc_IR_AttrDescriptionSeq), (char *) &_oc_IR_AttrDescriptionSeq, 0, sizeof (IR::AttrDescriptionSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttrDescriptionSeq, &_tc_TAO_tc_CORBA_AttrDescriptionSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_AttrDescriptionSeq, &_tc_TAO_tc_IR_AttrDescriptionSeq)
 TAO_NAMESPACE_END
-CORBA_InterfaceDef_ptr CORBA_InterfaceDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::InterfaceDef::_tao_any_destructor (void *x)
+{
+  InterfaceDef *tmp = ACE_static_cast (InterfaceDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::InterfaceDef_ptr IR::InterfaceDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_InterfaceDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/InterfaceDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_InterfaceDef::_nil ());
+    return InterfaceDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/InterfaceDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (InterfaceDef::_nil ());
   if (is_a == 0)
-    return CORBA_InterfaceDef::_nil ();
-  return CORBA_InterfaceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return InterfaceDef::_nil ();
+  return InterfaceDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_InterfaceDef_ptr CORBA_InterfaceDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::InterfaceDef_ptr IR::InterfaceDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_InterfaceDef::_nil ();
+    return InterfaceDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  InterfaceDef_ptr default_proxy = InterfaceDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_InterfaceDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_InterfaceDef_ptr retv = _TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_InterfaceDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_InterfaceDef_ptr retval = CORBA_InterfaceDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_InterfaceDef (stub),
-                  CORBA_InterfaceDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, InterfaceDef (stub), InterfaceDef::_nil ());
+  return TAO_IR_InterfaceDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_InterfaceDef_ptr
-CORBA_InterfaceDef::_duplicate (CORBA_InterfaceDef_ptr obj)
+IR::InterfaceDef_ptr 
+IR::InterfaceDef::_duplicate (InterfaceDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA_InterfaceDefSeq * CORBA_InterfaceDef::base_interfaces (
-    CORBA_Environment &ACE_TRY_ENV
+IR::InterfaceDefSeq * IR::InterfaceDef::base_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+  IR::InterfaceDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::InterfaceDefSeq, _tao_retval);
+  IR::InterfaceDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_base_interfaces",
+      20,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-  CORBA_InterfaceDefSeq* _tao_retval = 0;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_base_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_base_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_base_interfaces",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
+void IR::InterfaceDef::base_interfaces (
+    const IR::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
 
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW (CORBA::INTERNAL ());
 
-  ACE_NEW_RETURN (_tao_retval, CORBA_InterfaceDefSeq, _tao_retval);
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""base_interfaces",
+      "_set_base_interfaces",
       20,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_base_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << base_interfaces)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_base_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_base_interfaces",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+CORBA::Boolean IR::InterfaceDef::is_abstract (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_abstract",
+      16,
+      istub->orb_core ()
+    );
 
-    }
-    break;
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_abstract",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_abstract",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_is_abstract",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_InterfaceDef::base_interfaces (
-    const CORBA_InterfaceDefSeq & base_interfaces,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::InterfaceDef::is_abstract (
+    CORBA::Boolean is_abstract,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_is_abstract",
+      16,
+      istub->orb_core ()
+    );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_abstract",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << CORBA::Any::from_boolean (is_abstract))
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_abstract",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_is_abstract",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
+
+}
+
+CORBA::Boolean IR::InterfaceDef::is_local (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""base_interfaces",
-      20,
+      "_get_is_local",
+      13,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_local",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_local",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_is_local",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_retval;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
+void IR::InterfaceDef::is_local (
+    CORBA::Boolean is_local,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << base_interfaces)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_is_local",
+      13,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_local",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << CORBA::Any::from_boolean (is_local))
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_local",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_is_local",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_InterfaceDef::is_a (
+CORBA::Boolean IR::InterfaceDef::is_a (
     const char * interface_id,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
+  
   CORBA::Boolean _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
       "is_a",
@@ -10363,139 +22925,802 @@ CORBA::Boolean CORBA_InterfaceDef::is_a (
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "is_a",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << interface_id)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "is_a",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "is_a",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_retval;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+IR::AttributeDef_ptr IR::InterfaceDef::create_attribute (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr type,
+    IR::AttributeMode mode,
+    const IR::ExceptionDefSeq & get_exceptions,
+    const IR::ExceptionDefSeq & put_exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::AttributeDef_ptr _tao_retval = IR::AttributeDef::_nil ();
+  IR::AttributeDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << interface_id)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_attribute",
+      16,
+      istub->orb_core ()
+    );
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_attribute",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << type) &&
+              (_tao_out << mode) &&
+              (_tao_out << get_exceptions) &&
+              (_tao_out << put_exceptions)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_attribute",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_attribute",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
+IR::OperationDef_ptr IR::InterfaceDef::create_operation (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr result,
+    IR::OperationMode mode,
+    const IR::ParDescriptionSeq & params,
+    const IR::ExceptionDefSeq & exceptions,
+    const IR::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::OperationDef_ptr _tao_retval = IR::OperationDef::_nil ();
+  IR::OperationDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_operation",
+      16,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_operation",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << result) &&
+              (_tao_out << mode) &&
+              (_tao_out << params) &&
+              (_tao_out << exceptions) &&
+              (_tao_out << contexts)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_operation",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_operation",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Boolean IR::InterfaceDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/InterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::InterfaceDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/InterfaceDef:1.0";
+}
+
+IR::TAO_IR_InterfaceDef_Default_Proxy_Factory::TAO_IR_InterfaceDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_InterfaceDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_InterfaceDef_Default_Proxy_Factory::~TAO_IR_InterfaceDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::InterfaceDef_ptr
+IR::TAO_IR_InterfaceDef_Default_Proxy_Factory::create_proxy (
+    ::IR::InterfaceDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_InterfaceDef_Proxy_Factory_Adapter::TAO_IR_InterfaceDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_InterfaceDef_Proxy_Factory_Adapter::~TAO_IR_InterfaceDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_InterfaceDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_InterfaceDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_InterfaceDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::InterfaceDef_ptr
+IR::TAO_IR_InterfaceDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::InterfaceDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_InterfaceDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::TAO_IR_InterfaceDef_Smart_Proxy_Base (::IR::InterfaceDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::~TAO_IR_InterfaceDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::InterfaceDefSeq * IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::base_interfaces  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->base_interfaces (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::base_interfaces  (
+    const IR::InterfaceDefSeq & base_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->base_interfaces (
+      base_interfaces,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::Boolean IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::is_abstract  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_abstract (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::is_abstract  (
+    CORBA::Boolean is_abstract,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->is_abstract (
+      is_abstract,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::Boolean IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::is_local  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_local (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::is_local  (
+    CORBA::Boolean is_local,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->is_local (
+      is_local,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::Boolean IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::is_a  (
+    const char * interface_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_a (
+      interface_id,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::AttributeDef_ptr IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::create_attribute  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr type,
+    IR::AttributeMode mode,
+    const IR::ExceptionDefSeq & get_exceptions,
+    const IR::ExceptionDefSeq & put_exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_attribute (
+      id,
+      name,
+      version,
+      type,
+      mode,
+      get_exceptions,
+      put_exceptions,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::OperationDef_ptr IR::TAO_IR_InterfaceDef_Smart_Proxy_Base::create_operation  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr result,
+    IR::OperationMode mode,
+    const IR::ParDescriptionSeq & params,
+    const IR::ExceptionDefSeq & exceptions,
+    const IR::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_operation (
+      id,
+      name,
+      version,
+      result,
+      mode,
+      params,
+      exceptions,
+      contexts,
+      ACE_TRY_ENV
+    );
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> CORBA_Any::to_boolean (_tao_retval))
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
 }
 
-static const CORBA::Long _oc_CORBA_InterfaceDef_FullInterfaceDescription[] =
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_InterfaceDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_InterfaceDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_InterfaceDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  60, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x74657266), ACE_NTOHL (0x61636544), ACE_NTOHL (0x65662f46), ACE_NTOHL (0x756c6c49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef/FullInterfaceDescription:1.0
-  25, ACE_NTOHL (0x46756c6c), ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = FullInterfaceDescription
-  9, // member count
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
+  13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = InterfaceDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_InterfaceDef (CORBA::tk_objref, sizeof (_oc_IR_InterfaceDef), (char *) &_oc_IR_InterfaceDef, 0, sizeof (IR::InterfaceDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDef, &_tc_TAO_tc_IR_InterfaceDef)
+TAO_NAMESPACE_END
+static const CORBA::Long _oc_IR_InterfaceDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDescription:1.0
+  21, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = InterfaceDescription
+  10, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
   11, ACE_NTOHL (0x6f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e730000),  // name = operations
   CORBA::tk_alias, // typecode kind for typedefs
-  2036, // encapsulation length
+  2532, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OpDescriptionSeq:1.0
+    36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OpDescriptionSeq:1.0
     17, ACE_NTOHL (0x4f704465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x0),  // name = OpDescriptionSeq
     CORBA::tk_sequence, // typecode kind
-    1956, // encapsulation length
+    2456, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_struct, // typecode kind
-      1940, // encapsulation length
+      2440, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDescription:1.0
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
         21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
         9, // member count
         5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        132, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
           11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
 
         3, ACE_NTOHL (0x69640000),  // name = id
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        64, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
           12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string,
+          CORBA::tk_string, 
           0U, // string length
 
         7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
@@ -10505,7 +23730,7 @@ static const CORBA::Long _oc_CORBA_InterfaceDef_FullInterfaceDescription[] =
         CORBA::tk_enum, // typecode kind
         100, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
           14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
           2, // member count
           10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
@@ -10513,25 +23738,31 @@ static const CORBA::Long _oc_CORBA_InterfaceDef_FullInterfaceDescription[] =
 
         9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
         CORBA::tk_alias, // typecode kind for typedefs
-        236, // encapsulation length
+        296, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
           13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
           CORBA::tk_sequence, // typecode kind
-          164, // encapsulation length
+          228, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
             CORBA::tk_alias, // typecode kind for typedefs
-            148, // encapsulation length
+            212, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496465), ACE_NTOHL (0x6e746966), ACE_NTOHL (0x6965723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+              37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
               18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
               CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
+              132, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
                 11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
 
             0U,
@@ -10539,43 +23770,49 @@ static const CORBA::Long _oc_CORBA_InterfaceDef_FullInterfaceDescription[] =
 
         11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
         CORBA::tk_alias, // typecode kind for typedefs
-        496, // encapsulation length
+        552, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
           18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
           CORBA::tk_sequence, // typecode kind
-          416, // encapsulation length
+          472, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
             CORBA::tk_struct, // typecode kind
-            400, // encapsulation length
+            456, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x74657244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
               21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
               4, // member count
               5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
               CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
+              132, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
                 11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
               5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
               CORBA::tk_TypeCode,
 
               9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
               CORBA::tk_objref, // typecode kind
-              52, // encapsulation length
+              48, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+                27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
                 8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
               5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
               CORBA::tk_enum, // typecode kind
               116, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x7465724d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
                 14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
                 3, // member count
                 9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
@@ -10588,53 +23825,71 @@ static const CORBA::Long _oc_CORBA_InterfaceDef_FullInterfaceDescription[] =
 
         11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
         CORBA::tk_alias, // typecode kind for typedefs
-        556, // encapsulation length
+        748, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
           18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
           CORBA::tk_sequence, // typecode kind
-          476, // encapsulation length
+          668, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
             CORBA::tk_struct, // typecode kind
-            460, // encapsulation length
+            652, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
               21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
               5, // member count
               5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
               CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
+              132, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
                 11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
               3, ACE_NTOHL (0x69640000),  // name = id
               CORBA::tk_alias, // typecode kind for typedefs
-              72, // encapsulation length
+              140, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
                 13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
               11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
               CORBA::tk_alias, // typecode kind for typedefs
-              72, // encapsulation length
+              140, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
                 13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
               8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
               CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
+              64, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
                 12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string,
+                CORBA::tk_string, 
                 0U, // string length
 
               5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -10650,53 +23905,71 @@ static const CORBA::Long _oc_CORBA_InterfaceDef_FullInterfaceDescription[] =
 
   11, ACE_NTOHL (0x61747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65730000),  // name = attributes
   CORBA::tk_alias, // typecode kind for typedefs
-  684, // encapsulation length
+  2424, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
+    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
     19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
     CORBA::tk_sequence, // typecode kind
-    600, // encapsulation length
+    2344, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_struct, // typecode kind
-      584, // encapsulation length
+      2328, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x75746544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
         21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-        6, // member count
+        8, // member count
         5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        132, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
           11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
 
         3, ACE_NTOHL (0x69640000),  // name = id
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        64, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
           12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string,
+          CORBA::tk_string, 
           0U, // string length
 
         5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -10706,421 +23979,273 @@ static const CORBA::Long _oc_CORBA_InterfaceDef_FullInterfaceDescription[] =
         CORBA::tk_enum, // typecode kind
         104, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x7574654d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
           14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
           2, // member count
           12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
           14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
 
+        15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        748, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          668, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            652, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
 
-      0U,
-
-
-  16, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f696e74), ACE_NTOHL (0x65726661), ACE_NTOHL (0x63657300),  // name = base_interfaces
-  CORBA::tk_alias, // typecode kind for typedefs
-  164, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49645365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
-    16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
-    CORBA::tk_sequence, // typecode kind
-    88, // encapsulation length
-      TAO_ENCAP_BYTE_ORDER, // byte order
-      CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
-        TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
-        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
-
-      0U,
-
-
-  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
-  CORBA::tk_TypeCode,
-
-  12, ACE_NTOHL (0x69735f61), ACE_NTOHL (0x62737472), ACE_NTOHL (0x61637400),  // name = is_abstract
-  CORBA::tk_boolean,
-
-};
-static CORBA::TypeCode _tc_TAO_tc_CORBA_InterfaceDef_FullInterfaceDescription (CORBA::tk_struct, sizeof (_oc_CORBA_InterfaceDef_FullInterfaceDescription), (char *) &_oc_CORBA_InterfaceDef_FullInterfaceDescription, 0, sizeof (CORBA_InterfaceDef::FullInterfaceDescription));
-CORBA::TypeCode_ptr CORBA_InterfaceDef::_tc_FullInterfaceDescription = &_tc_TAO_tc_CORBA_InterfaceDef_FullInterfaceDescription;
-
-CORBA_InterfaceDef::FullInterfaceDescription * CORBA_InterfaceDef::describe_interface (
-    CORBA_Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-
-  CORBA_InterfaceDef::FullInterfaceDescription* _tao_retval = 0;
-
-  TAO_Stub *istub = this->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_InterfaceDef::FullInterfaceDescription, _tao_retval);
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "describe_interface",
-      18,
-      istub->orb_core ()
-    );
-
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
-
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
-    }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
-}
-
-CORBA_AttributeDef_ptr CORBA_InterfaceDef::create_attribute (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA_IDLType_ptr type,
-    CORBA::AttributeMode mode,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-
-  CORBA_AttributeDef_ptr _tao_retval = CORBA_AttributeDef::_nil ();
-
-
-  TAO_Stub *istub = this->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
-
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_attribute",
-      16,
-      istub->orb_core ()
-    );
-
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << type) &&
-          (_tao_out << mode)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+              3, ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
 
-    }
-    break;
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
-}
-
-CORBA_OperationDef_ptr CORBA_InterfaceDef::create_operation (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA_IDLType_ptr result,
-    CORBA::OperationMode mode,
-    const CORBA_ParDescriptionSeq & params,
-    const CORBA_ExceptionDefSeq & exceptions,
-    const CORBA_ContextIdSeq & contexts,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
+              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              64, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
 
-  CORBA_OperationDef_ptr _tao_retval = CORBA_OperationDef::_nil ();
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
 
 
-  TAO_Stub *istub = this->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+            0U,
 
 
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "create_operation",
-      16,
-      istub->orb_core ()
-    );
+        15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        748, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          668, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            652, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
 
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+              3, ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
 
-    CORBA::Short flag = 131;
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << result) &&
-          (_tao_out << mode) &&
-          (_tao_out << params) &&
-          (_tao_out << exceptions) &&
-          (_tao_out << contexts)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              64, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
 
-    }
-    break;
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
-}
+            0U,
 
-CORBA::Boolean CORBA_InterfaceDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/InterfaceDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
-  return 1; // success using local knowledge
-  else
-    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
-}
 
-const char* CORBA_InterfaceDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/InterfaceDef:1.0";
-}
 
-static const CORBA::Long _oc_CORBA_InterfaceDef[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x74657266), ACE_NTOHL (0x61636544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDef:1.0
-  13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = InterfaceDef
-};
-static CORBA::TypeCode _tc_TAO_tc_CORBA_InterfaceDef (CORBA::tk_objref, sizeof (_oc_CORBA_InterfaceDef), (char *) &_oc_CORBA_InterfaceDef, 0, sizeof (CORBA_InterfaceDef));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDef, &_tc_TAO_tc_CORBA_InterfaceDef)
-TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_InterfaceDescription[] =
-{
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x74657266), ACE_NTOHL (0x61636544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/InterfaceDescription:1.0
-  21, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = InterfaceDescription
-  6, // member count
-  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
-    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
-
-  3, ACE_NTOHL (0x69640000),  // name = id
-  CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
-
-  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
-  CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
-    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+      0U,
 
-  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
-  CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
-    TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
-    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
-    0U, // string length
 
   16, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f696e74), ACE_NTOHL (0x65726661), ACE_NTOHL (0x63657300),  // name = base_interfaces
   CORBA::tk_alias, // typecode kind for typedefs
-  164, // encapsulation length
+  228, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49645365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
     16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
     CORBA::tk_sequence, // typecode kind
-    88, // encapsulation length
+    156, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       0U,
 
 
+  5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+  CORBA::tk_TypeCode,
+
   12, ACE_NTOHL (0x69735f61), ACE_NTOHL (0x62737472), ACE_NTOHL (0x61637400),  // name = is_abstract
   CORBA::tk_boolean,
 
+  9, ACE_NTOHL (0x69735f6c), ACE_NTOHL (0x6f63616c), ACE_NTOHL (0x0),  // name = is_local
+  CORBA::tk_boolean,
+
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_InterfaceDescription (CORBA::tk_struct, sizeof (_oc_CORBA_InterfaceDescription), (char *) &_oc_CORBA_InterfaceDescription, 0, sizeof (CORBA_InterfaceDescription));
+static CORBA::TypeCode _tc_TAO_tc_IR_InterfaceDescription (CORBA::tk_struct, sizeof (_oc_IR_InterfaceDescription), (char *) &_oc_IR_InterfaceDescription, 0, sizeof (IR::InterfaceDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDescription, &_tc_TAO_tc_CORBA_InterfaceDescription)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_InterfaceDescription, &_tc_TAO_tc_IR_InterfaceDescription)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_Visibility[] =
+void IR::InterfaceDescription::_tao_any_destructor (void *x)
 {
-  TAO_ENCAP_BYTE_ORDER, // byte order
-  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5669), ACE_NTOHL (0x73696269), ACE_NTOHL (0x6c697479), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Visibility:1.0
-  11, ACE_NTOHL (0x56697369), ACE_NTOHL (0x62696c69), ACE_NTOHL (0x74790000),  // name = Visibility
-  CORBA::tk_short,
+  InterfaceDescription *tmp = ACE_static_cast (InterfaceDescription*,x);
+  delete tmp;
+}
 
-};
-static CORBA::TypeCode _tc_TAO_tc_CORBA_Visibility (CORBA::tk_alias, sizeof (_oc_CORBA_Visibility), (char *) &_oc_CORBA_Visibility, 0, sizeof (CORBA::Visibility));
-TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_Visibility, &_tc_TAO_tc_CORBA_Visibility)
-TAO_NAMESPACE_END
-TAO_NAMESPACE_TYPE (const CORBA::Short)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (const CORBA::Short, PRIVATE_MEMBER, 0)
-TAO_NAMESPACE_END
-TAO_NAMESPACE_TYPE (const CORBA::Short)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (const CORBA::Short, PUBLIC_MEMBER, 1)
-TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_ValueMember[] =
+static const CORBA::Long _oc_IR_ValueMember[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c75654d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueMember:1.0
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueMember:1.0
   12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657200),  // name = ValueMember
   7, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
   5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -11128,9 +24253,9 @@ static const CORBA::Long _oc_CORBA_ValueMember[] =
 
   9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
   CORBA::tk_objref, // typecode kind
-  52, // encapsulation length
+  48, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+    27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
     8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
   7, ACE_NTOHL (0x61636365), ACE_NTOHL (0x73730000),  // name = access
@@ -11143,150 +24268,179 @@ static const CORBA::Long _oc_CORBA_ValueMember[] =
 
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueMember (CORBA::tk_struct, sizeof (_oc_CORBA_ValueMember), (char *) &_oc_CORBA_ValueMember, 0, sizeof (CORBA_ValueMember));
+static CORBA::TypeCode _tc_TAO_tc_IR_ValueMember (CORBA::tk_struct, sizeof (_oc_IR_ValueMember), (char *) &_oc_IR_ValueMember, 0, sizeof (IR::ValueMember));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMember, &_tc_TAO_tc_CORBA_ValueMember)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMember, &_tc_TAO_tc_IR_ValueMember)
 TAO_NAMESPACE_END
+void IR::ValueMember::_tao_any_destructor (void *x)
+{
+  ValueMember *tmp = ACE_static_cast (ValueMember*,x);
+  delete tmp;
+}
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CS_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CS_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_VALUEMEMBERSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_VALUEMEMBERSEQ_CS_
 
   void
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_allocate_buffer (CORBA::ULong length)
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::_allocate_buffer (CORBA::ULong length)
   {
-    CORBA_ValueMember* tmp = 0;
-    tmp = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (length);
-
+    IR::ValueMember* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (length);
+    
     if (this->buffer_ != 0)
     {
-      CORBA_ValueMember *old = ACE_reinterpret_cast (CORBA_ValueMember *,this->buffer_);
-
+      IR::ValueMember *old = ACE_reinterpret_cast (IR::ValueMember *,this->buffer_);
+      
       for (CORBA::ULong i = 0; i < this->length_; ++i)
         tmp[i] = old[i];
-
+      
       if (this->release_)
-        _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (old);
-
+        _TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (old);
+      
     }
     this->buffer_ = tmp;
   }
-
+  
   void
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_deallocate_buffer (void)
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::_deallocate_buffer (void)
   {
     if (this->buffer_ == 0 || this->release_ == 0)
       return;
-
-    CORBA_ValueMember *tmp = ACE_reinterpret_cast (CORBA_ValueMember *,this->buffer_);
-
-    _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (tmp);
+    
+    IR::ValueMember *tmp = ACE_reinterpret_cast (IR::ValueMember *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (tmp);
     this->buffer_ = 0;
-  }
-
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::~_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Dtor.
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::~_TAO_Unbounded_Sequence_IR_ValueMemberSeq (void) // Dtor.
   {
     this->_deallocate_buffer ();
   }
-
-
+  
+  
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_VALUEMEMBERSEQ_CS_)
-#define _CORBA_VALUEMEMBERSEQ_CS_
+#if !defined (_IR_VALUEMEMBERSEQ_CS_)
+#define _IR_VALUEMEMBERSEQ_CS_
 
 // *************************************************************
-// CORBA_ValueMemberSeq
+// IR::ValueMemberSeq
 // *************************************************************
 
-CORBA_ValueMemberSeq::CORBA_ValueMemberSeq (void)
+IR::ValueMemberSeq::ValueMemberSeq (void)
 {}
-CORBA_ValueMemberSeq::CORBA_ValueMemberSeq (CORBA::ULong max) // uses max size
-  :
+IR::ValueMemberSeq::ValueMemberSeq (CORBA::ULong max) // uses max size
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq
+  _TAO_Unbounded_Sequence_IR_ValueMemberSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ValueMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ValueMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max)
 {}
-CORBA_ValueMemberSeq::CORBA_ValueMemberSeq (CORBA::ULong max, CORBA::ULong length, CORBA_ValueMember *buffer, CORBA::Boolean release)
-  :
+IR::ValueMemberSeq::ValueMemberSeq (CORBA::ULong max, CORBA::ULong length, IR::ValueMember *buffer, CORBA::Boolean release)
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq
+  _TAO_Unbounded_Sequence_IR_ValueMemberSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ValueMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ValueMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (max, length, buffer, release)
 {}
-CORBA_ValueMemberSeq::CORBA_ValueMemberSeq (const CORBA_ValueMemberSeq &seq) // copy ctor
-  :
+IR::ValueMemberSeq::ValueMemberSeq (const ValueMemberSeq &seq) // copy ctor
+  : 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq
+  _TAO_Unbounded_Sequence_IR_ValueMemberSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-  TAO_Unbounded_Sequence<CORBA_ValueMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ValueMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
  (seq)
 {}
-CORBA_ValueMemberSeq::~CORBA_ValueMemberSeq (void) // dtor
+IR::ValueMemberSeq::~ValueMemberSeq (void) // dtor
 {}
+void IR::ValueMemberSeq::_tao_any_destructor (void *x)
+{
+  ValueMemberSeq *tmp = ACE_static_cast (ValueMemberSeq*,x);
+  delete tmp;
+}
 
 
 #endif /* end #if !defined */
 
-static const CORBA::Long _oc_CORBA_ValueMemberSeq[] =
+static const CORBA::Long _oc_IR_ValueMemberSeq[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c75654d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x72536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ValueMemberSeq:1.0
+  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ValueMemberSeq:1.0
   15, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65710000),  // name = ValueMemberSeq
   CORBA::tk_sequence, // typecode kind
-  616, // encapsulation length
+  804, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
     CORBA::tk_struct, // typecode kind
-    600, // encapsulation length
+    788, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
-      34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c75654d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueMember:1.0
+      31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueMember:1.0
       12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657200),  // name = ValueMember
       7, // member count
       5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      132, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
         11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
 
       3, ACE_NTOHL (0x69640000),  // name = id
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
       CORBA::tk_alias, // typecode kind for typedefs
-      68, // encapsulation length
+      64, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
         12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-        CORBA::tk_string,
+        CORBA::tk_string, 
         0U, // string length
 
       5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -11294,9 +24448,9 @@ static const CORBA::Long _oc_CORBA_ValueMemberSeq[] =
 
       9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
       CORBA::tk_objref, // typecode kind
-      52, // encapsulation length
+      48, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
         8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
       7, ACE_NTOHL (0x61636365), ACE_NTOHL (0x73730000),  // name = access
@@ -11312,362 +24466,651 @@ static const CORBA::Long _oc_CORBA_ValueMemberSeq[] =
     0U,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueMemberSeq (CORBA::tk_alias, sizeof (_oc_CORBA_ValueMemberSeq), (char *) &_oc_CORBA_ValueMemberSeq, 0, sizeof (CORBA_ValueMemberSeq));
+static CORBA::TypeCode _tc_TAO_tc_IR_ValueMemberSeq (CORBA::tk_alias, sizeof (_oc_IR_ValueMemberSeq), (char *) &_oc_IR_ValueMemberSeq, 0, sizeof (IR::ValueMemberSeq));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMemberSeq, &_tc_TAO_tc_CORBA_ValueMemberSeq)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMemberSeq, &_tc_TAO_tc_IR_ValueMemberSeq)
 TAO_NAMESPACE_END
-CORBA_ValueMemberDef_ptr CORBA_ValueMemberDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ValueMemberDef::_tao_any_destructor (void *x)
+{
+  ValueMemberDef *tmp = ACE_static_cast (ValueMemberDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ValueMemberDef_ptr IR::ValueMemberDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ValueMemberDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ValueMemberDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_ValueMemberDef::_nil ());
+    return ValueMemberDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ValueMemberDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ValueMemberDef::_nil ());
   if (is_a == 0)
-    return CORBA_ValueMemberDef::_nil ();
-  return CORBA_ValueMemberDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return ValueMemberDef::_nil ();
+  return ValueMemberDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_ValueMemberDef_ptr CORBA_ValueMemberDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::ValueMemberDef_ptr IR::ValueMemberDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ValueMemberDef::_nil ();
+    return ValueMemberDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  ValueMemberDef_ptr default_proxy = ValueMemberDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ValueMemberDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_ValueMemberDef_ptr retv = _TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_ValueMemberDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_ValueMemberDef_ptr retval = CORBA_ValueMemberDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_ValueMemberDef (stub),
-                  CORBA_ValueMemberDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ValueMemberDef (stub), ValueMemberDef::_nil ());
+  return TAO_IR_ValueMemberDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_ValueMemberDef_ptr
-CORBA_ValueMemberDef::_duplicate (CORBA_ValueMemberDef_ptr obj)
+IR::ValueMemberDef_ptr 
+IR::ValueMemberDef::_duplicate (ValueMemberDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA::TypeCode_ptr CORBA_ValueMemberDef::type (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::TypeCode_ptr IR::ValueMemberDef::type (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA::TypeCode_ptr _tao_retval = 0;
-
-
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""type",
+      "_get_type",
       9,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA_IDLType_ptr CORBA_ValueMemberDef::type_def (
-    CORBA_Environment &ACE_TRY_ENV
+IR::IDLType_ptr IR::ValueMemberDef::type_def (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_IDLType_ptr _tao_retval = CORBA_IDLType::_nil ();
-
-
+  
+  IR::IDLType_ptr _tao_retval = IR::IDLType::_nil ();
+  IR::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""type_def",
+      "_get_type_def",
       13,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ValueMemberDef::type_def (
-    CORBA_IDLType_ptr type_def,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ValueMemberDef::type_def (
+    IR::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""type_def",
+      "_set_type_def",
       13,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << type_def)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << type_def)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Visibility CORBA_ValueMemberDef::access (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::Visibility IR::ValueMemberDef::access (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
+  
   CORBA::Visibility _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""access",
+      "_get_access",
       11,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_access",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_retval)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_access",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_access",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_ValueMemberDef::access (
+void IR::ValueMemberDef::access (
     CORBA::Visibility access,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""access",
+      "_set_access",
       11,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << access)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_access",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << access)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_access",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_access",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_ValueMemberDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::ValueMemberDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ValueMemberDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ValueMemberDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -11675,1000 +25118,2888 @@ CORBA::Boolean CORBA_ValueMemberDef::_is_a (const CORBA::Char *value, CORBA_Envi
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_ValueMemberDef::_interface_repository_id (void) const
+const char* IR::ValueMemberDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ValueMemberDef:1.0";
+}
+
+IR::TAO_IR_ValueMemberDef_Default_Proxy_Factory::TAO_IR_ValueMemberDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_ValueMemberDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ValueMemberDef_Default_Proxy_Factory::~TAO_IR_ValueMemberDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ValueMemberDef_ptr
+IR::TAO_IR_ValueMemberDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ValueMemberDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ValueMemberDef_Proxy_Factory_Adapter::TAO_IR_ValueMemberDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ValueMemberDef_Proxy_Factory_Adapter::~TAO_IR_ValueMemberDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ValueMemberDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ValueMemberDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ValueMemberDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::ValueMemberDef_ptr
+IR::TAO_IR_ValueMemberDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ValueMemberDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ValueMemberDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_ValueMemberDef_Smart_Proxy_Base::TAO_IR_ValueMemberDef_Smart_Proxy_Base (::IR::ValueMemberDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ValueMemberDef_Smart_Proxy_Base::~TAO_IR_ValueMemberDef_Smart_Proxy_Base (void)
 {
-  return "IDL:omg.org/CORBA/ValueMemberDef:1.0";
 }
 
-static const CORBA::Long _oc_CORBA_ValueMemberDef[] =
+TAO_Stub *
+IR::TAO_IR_ValueMemberDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::TypeCode_ptr IR::TAO_IR_ValueMemberDef_Smart_Proxy_Base::type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->type (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::IDLType_ptr IR::TAO_IR_ValueMemberDef_Smart_Proxy_Base::type_def  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->type_def (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_ValueMemberDef_Smart_Proxy_Base::type_def  (
+    IR::IDLType_ptr type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->type_def (
+      type_def,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::Visibility IR::TAO_IR_ValueMemberDef_Smart_Proxy_Base::access  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->access (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_ValueMemberDef_Smart_Proxy_Base::access  (
+    CORBA::Visibility access,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->access (
+      access,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ValueMemberDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ValueMemberDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ValueMemberDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c75654d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x72446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ValueMemberDef:1.0
+  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65724465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ValueMemberDef:1.0
   15, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657244), ACE_NTOHL (0x65660000),  // name = ValueMemberDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueMemberDef (CORBA::tk_objref, sizeof (_oc_CORBA_ValueMemberDef), (char *) &_oc_CORBA_ValueMemberDef, 0, sizeof (CORBA_ValueMemberDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_ValueMemberDef (CORBA::tk_objref, sizeof (_oc_IR_ValueMemberDef), (char *) &_oc_IR_ValueMemberDef, 0, sizeof (IR::ValueMemberDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMemberDef, &_tc_TAO_tc_CORBA_ValueMemberDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueMemberDef, &_tc_TAO_tc_IR_ValueMemberDef)
 TAO_NAMESPACE_END
-CORBA_ValueDef_ptr CORBA_ValueDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ValueDef::_tao_any_destructor (void *x)
+{
+  ValueDef *tmp = ACE_static_cast (ValueDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ValueDef_ptr IR::ValueDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ValueDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ValueDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_ValueDef::_nil ());
+    return ValueDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ValueDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ValueDef::_nil ());
   if (is_a == 0)
-    return CORBA_ValueDef::_nil ();
-  return CORBA_ValueDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return ValueDef::_nil ();
+  return ValueDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_ValueDef_ptr CORBA_ValueDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::ValueDef_ptr IR::ValueDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ValueDef::_nil ();
+    return ValueDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  ValueDef_ptr default_proxy = ValueDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ValueDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_ValueDef_ptr retv = _TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_ValueDef_Stub_Factory_function_pointer (obj);
     }
-
-  CORBA_ValueDef_ptr retval = CORBA_ValueDef::_nil ();
-
-  ACE_NEW_RETURN (retval,
-                  CORBA_ValueDef (stub),
-                  CORBA_ValueDef::_nil ());
-
-  return retval;
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ValueDef (stub), ValueDef::_nil ());
+  return TAO_IR_ValueDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_ValueDef_ptr
-CORBA_ValueDef::_duplicate (CORBA_ValueDef_ptr obj)
+IR::ValueDef_ptr 
+IR::ValueDef::_duplicate (ValueDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA_InterfaceDef_ptr CORBA_ValueDef::supported_interface (
-    CORBA_Environment &ACE_TRY_ENV
+IR::InterfaceDefSeq * IR::ValueDef::supported_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_InterfaceDef_ptr _tao_retval = CORBA_InterfaceDef::_nil ();
-
-
+  
+  IR::InterfaceDefSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
+  ACE_NEW_RETURN (_tao_retval, IR::InterfaceDefSeq, _tao_retval);
+  IR::InterfaceDefSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""supported_interface",
-      24,
+      "_get_supported_interfaces",
+      25,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_supported_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_supported_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_supported_interfaces",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ValueDef::supported_interface (
-    CORBA_InterfaceDef_ptr supported_interface,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ValueDef::supported_interfaces (
+    const IR::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""supported_interface",
-      24,
+      "_set_supported_interfaces",
+      25,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << supported_interface)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_supported_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << supported_interfaces)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_supported_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_supported_interfaces",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA_InitializerSeq * CORBA_ValueDef::initializers (
-    CORBA_Environment &ACE_TRY_ENV
+IR::InitializerSeq * IR::ValueDef::initializers (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_InitializerSeq* _tao_retval = 0;
-
-
+  
+  IR::InitializerSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_InitializerSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::InitializerSeq, _tao_retval);
+  IR::InitializerSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""initializers",
+      "_get_initializers",
       17,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_initializers",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_initializers",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_initializers",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ValueDef::initializers (
-    const CORBA_InitializerSeq & initializers,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ValueDef::initializers (
+    const IR::InitializerSeq & initializers,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""initializers",
+      "_set_initializers",
       17,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << initializers)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_initializers",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << initializers)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_initializers",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_initializers",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA_ValueDef_ptr CORBA_ValueDef::base_value (
-    CORBA_Environment &ACE_TRY_ENV
+IR::ValueDef_ptr IR::ValueDef::base_value (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_ValueDef_ptr _tao_retval = CORBA_ValueDef::_nil ();
-
-
+  
+  IR::ValueDef_ptr _tao_retval = IR::ValueDef::_nil ();
+  IR::ValueDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""base_value",
+      "_get_base_value",
       15,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_base_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_base_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_base_value",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ValueDef::base_value (
-    CORBA_ValueDef_ptr base_value,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ValueDef::base_value (
+    IR::ValueDef_ptr base_value,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""base_value",
+      "_set_base_value",
       15,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << base_value)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_base_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << base_value)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_base_value",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_base_value",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA_ValueDefSeq * CORBA_ValueDef::abstract_base_values (
-    CORBA_Environment &ACE_TRY_ENV
+IR::ValueDefSeq * IR::ValueDef::abstract_base_values (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
-  CORBA_ValueDefSeq* _tao_retval = 0;
-
-
+  
+  IR::ValueDefSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_ValueDefSeq, _tao_retval);
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ValueDefSeq, _tao_retval);
+  IR::ValueDefSeq_var _tao_safe_retval (_tao_retval);
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""abstract_base_values",
+      "_get_abstract_base_values",
       25,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_abstract_base_values",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_abstract_base_values",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_abstract_base_values",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ValueDef::abstract_base_values (
-    const CORBA_ValueDefSeq & abstract_base_values,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ValueDef::abstract_base_values (
+    const IR::ValueDefSeq & abstract_base_values,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""abstract_base_values",
+      "_set_abstract_base_values",
       25,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
-
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << abstract_base_values)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
         ACE_CHECK;
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_abstract_base_values",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << abstract_base_values)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_abstract_base_values",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_abstract_base_values",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
 }
 
-CORBA::Boolean CORBA_ValueDef::is_abstract (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::Boolean IR::ValueDef::is_abstract (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-
+  
   CORBA::Boolean _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""is_abstract",
+      "_get_is_abstract",
       16,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    CORBA::Short flag = 131;
-
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
-
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_abstract",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_abstract",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_is_abstract",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
     }
-    break;
-
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> CORBA_Any::to_boolean (_tao_retval))
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_ValueDef::is_abstract (
+void IR::ValueDef::is_abstract (
     CORBA::Boolean is_abstract,
-    CORBA_Environment &ACE_TRY_ENV
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""is_abstract",
+      "_set_is_abstract",
       16,
       istub->orb_core ()
     );
 
-
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
     ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
-    CORBA::Short flag = 131;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_abstract",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << CORBA::Any::from_boolean (is_abstract))
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_abstract",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_is_abstract",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << CORBA_Any::from_boolean (is_abstract))
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK;
+CORBA::Boolean IR::ValueDef::is_custom (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_custom",
+      14,
+      istub->orb_core ()
+    );
 
-    }
-    break;
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  }
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_custom",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_custom",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_is_custom",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_retval;
 }
 
-CORBA::Boolean CORBA_ValueDef::is_custom (
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ValueDef::is_custom (
+    CORBA::Boolean is_custom,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
 
-  CORBA::Boolean _tao_retval = 0;
-
-
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""is_custom",
+      "_set_is_custom",
       14,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_custom",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << CORBA::Any::from_boolean (is_custom))
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_custom",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_is_custom",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+CORBA::Boolean IR::ValueDef::is_truncatable (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_truncatable",
+      19,
+      istub->orb_core ()
+    );
 
-    }
-    break;
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> CORBA_Any::to_boolean (_tao_retval))
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_truncatable",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_truncatable",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_is_truncatable",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-void CORBA_ValueDef::is_custom (
-    CORBA::Boolean is_custom,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::ValueDef::is_truncatable (
+    CORBA::Boolean is_truncatable,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
 
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_set_is_truncatable",
+      19,
+      istub->orb_core ()
+    );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_truncatable",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << CORBA::Any::from_boolean (is_truncatable))
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_is_truncatable",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_is_truncatable",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
+
+}
+
+CORBA::Boolean IR::ValueDef::is_a (
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""is_custom",
-      14,
+      "is_a",
+      4,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "is_a",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "is_a",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "is_a",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_retval;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
+IR::ValueMemberDef_ptr IR::ValueDef::create_value_member (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr type,
+    CORBA::Visibility access,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ValueMemberDef_ptr _tao_retval = IR::ValueMemberDef::_nil ();
+  IR::ValueMemberDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << CORBA_Any::from_boolean (is_custom))
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_value_member",
+      19,
+      istub->orb_core ()
+    );
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK;
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value_member",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << type) &&
+              (_tao_out << access)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value_member",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
-
-  }
-
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_value_member",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA::Boolean CORBA_ValueDef::is_truncatable (
-    CORBA_Environment &ACE_TRY_ENV
+IR::AttributeDef_ptr IR::ValueDef::create_attribute (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr type,
+    IR::AttributeMode mode,
+    const IR::ExceptionDefSeq & get_exceptions,
+    const IR::ExceptionDefSeq & put_exceptions,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+  IR::AttributeDef_ptr _tao_retval = IR::AttributeDef::_nil ();
+  IR::AttributeDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-  CORBA::Boolean _tao_retval = 0;
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_attribute",
+      16,
+      istub->orb_core ()
+    );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_attribute",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << type) &&
+              (_tao_out << mode) &&
+              (_tao_out << get_exceptions) &&
+              (_tao_out << put_exceptions)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_attribute",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_attribute",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+IR::OperationDef_ptr IR::ValueDef::create_operation (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr result,
+    IR::OperationMode mode,
+    const IR::ParDescriptionSeq & params,
+    const IR::ExceptionDefSeq & exceptions,
+    const IR::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::OperationDef_ptr _tao_retval = IR::OperationDef::_nil ();
+  IR::OperationDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""is_truncatable",
-      19,
+      "create_operation",
+      16,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_operation",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << result) &&
+              (_tao_out << mode) &&
+              (_tao_out << params) &&
+              (_tao_out << exceptions) &&
+              (_tao_out << contexts)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_operation",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_operation",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+CORBA::Boolean IR::ValueDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ValueDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+const char* IR::ValueDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ValueDef:1.0";
+}
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+IR::TAO_IR_ValueDef_Default_Proxy_Factory::TAO_IR_ValueDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+      TAO_IR_ValueDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ValueDef_Default_Proxy_Factory::~TAO_IR_ValueDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ValueDef_ptr
+IR::TAO_IR_ValueDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ValueDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
 
+IR::TAO_IR_ValueDef_Proxy_Factory_Adapter::TAO_IR_ValueDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ValueDef_Proxy_Factory_Adapter::~TAO_IR_ValueDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ValueDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ValueDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ValueDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
     }
-    break;
+return 0;
+}
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> CORBA_Any::to_boolean (_tao_retval))
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+IR::ValueDef_ptr
+IR::TAO_IR_ValueDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ValueDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ValueDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
 }
 
-void CORBA_ValueDef::is_truncatable (
-    CORBA::Boolean is_truncatable,
-    CORBA_Environment &ACE_TRY_ENV
+IR::TAO_IR_ValueDef_Smart_Proxy_Base::TAO_IR_ValueDef_Smart_Proxy_Base (::IR::ValueDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ValueDef_Smart_Proxy_Base::~TAO_IR_ValueDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ValueDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::InterfaceDefSeq * IR::TAO_IR_ValueDef_Smart_Proxy_Base::supported_interfaces  (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  return this->base_proxy_->supported_interfaces (
+      ACE_TRY_ENV
+    );
 
+}
 
+void IR::TAO_IR_ValueDef_Smart_Proxy_Base::supported_interfaces  (
+    const IR::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->supported_interfaces (
+      supported_interfaces,
+      ACE_TRY_ENV
+    );
 
+}
 
-  TAO_Stub *istub = this->_stubobj ();
-  if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
+IR::InitializerSeq * IR::TAO_IR_ValueDef_Smart_Proxy_Base::initializers  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->initializers (
+      ACE_TRY_ENV
+    );
 
+}
 
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "_set_""is_truncatable",
-      19,
-      istub->orb_core ()
+void IR::TAO_IR_ValueDef_Smart_Proxy_Base::initializers  (
+    const IR::InitializerSeq & initializers,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->initializers (
+      initializers,
+      ACE_TRY_ENV
     );
 
+}
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
+IR::ValueDef_ptr IR::TAO_IR_ValueDef_Smart_Proxy_Base::base_value  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->base_value (
+      ACE_TRY_ENV
+    );
 
-    CORBA::Short flag = 131;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
+void IR::TAO_IR_ValueDef_Smart_Proxy_Base::base_value  (
+    IR::ValueDef_ptr base_value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->base_value (
+      base_value,
+      ACE_TRY_ENV
+    );
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << CORBA_Any::from_boolean (is_truncatable))
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK;
+IR::ValueDefSeq * IR::TAO_IR_ValueDef_Smart_Proxy_Base::abstract_base_values  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->abstract_base_values (
+      ACE_TRY_ENV
+    );
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+}
 
-    }
-    break;
+void IR::TAO_IR_ValueDef_Smart_Proxy_Base::abstract_base_values  (
+    const IR::ValueDefSeq & abstract_base_values,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->abstract_base_values (
+      abstract_base_values,
+      ACE_TRY_ENV
+    );
 
-  }
+}
+
+CORBA::Boolean IR::TAO_IR_ValueDef_Smart_Proxy_Base::is_abstract  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_abstract (
+      ACE_TRY_ENV
+    );
 
 }
 
-CORBA::Boolean CORBA_ValueDef::is_a (
-    const char * value_id,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::TAO_IR_ValueDef_Smart_Proxy_Base::is_abstract  (
+    CORBA::Boolean is_abstract,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  this->base_proxy_->is_abstract (
+      is_abstract,
+      ACE_TRY_ENV
+    );
 
-  CORBA::Boolean _tao_retval = 0;
+}
 
+CORBA::Boolean IR::TAO_IR_ValueDef_Smart_Proxy_Base::is_custom  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_custom (
+      ACE_TRY_ENV
+    );
 
-  TAO_Stub *istub = this->_stubobj ();
-  if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+}
 
+void IR::TAO_IR_ValueDef_Smart_Proxy_Base::is_custom  (
+    CORBA::Boolean is_custom,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->is_custom (
+      is_custom,
+      ACE_TRY_ENV
+    );
 
-  TAO_GIOP_Twoway_Invocation _tao_call (
-      istub,
-      "is_a",
-      4,
-      istub->orb_core ()
+}
+
+CORBA::Boolean IR::TAO_IR_ValueDef_Smart_Proxy_Base::is_truncatable  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_truncatable (
+      ACE_TRY_ENV
     );
 
+}
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+void IR::TAO_IR_ValueDef_Smart_Proxy_Base::is_truncatable  (
+    CORBA::Boolean is_truncatable,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->is_truncatable (
+      is_truncatable,
+      ACE_TRY_ENV
+    );
 
-    CORBA::Short flag = 131;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+CORBA::Boolean IR::TAO_IR_ValueDef_Smart_Proxy_Base::is_a  (
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_a (
+      id,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ValueMemberDef_ptr IR::TAO_IR_ValueDef_Smart_Proxy_Base::create_value_member  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr type,
+    CORBA::Visibility access,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_value_member (
+      id,
+      name,
+      version,
+      type,
+      access,
+      ACE_TRY_ENV
+    );
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << value_id)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+IR::AttributeDef_ptr IR::TAO_IR_ValueDef_Smart_Proxy_Base::create_attribute  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr type,
+    IR::AttributeMode mode,
+    const IR::ExceptionDefSeq & get_exceptions,
+    const IR::ExceptionDefSeq & put_exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_attribute (
+      id,
+      name,
+      version,
+      type,
+      mode,
+      get_exceptions,
+      put_exceptions,
+      ACE_TRY_ENV
+    );
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+}
 
-    }
-    break;
+IR::OperationDef_ptr IR::TAO_IR_ValueDef_Smart_Proxy_Base::create_operation  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr result,
+    IR::OperationMode mode,
+    const IR::ParDescriptionSeq & params,
+    const IR::ExceptionDefSeq & exceptions,
+    const IR::ContextIdSeq & contexts,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_operation (
+      id,
+      name,
+      version,
+      result,
+      mode,
+      params,
+      exceptions,
+      contexts,
+      ACE_TRY_ENV
+    );
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> CORBA_Any::to_boolean (_tao_retval))
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
 }
 
-static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ValueDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ValueDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ValueDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  52, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c756544), ACE_NTOHL (0x65662f46), ACE_NTOHL (0x756c6c56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ValueDef/FullValueDescription:1.0
-  21, ACE_NTOHL (0x46756c6c), ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = FullValueDescription
+  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDef:1.0
+  9, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = ValueDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ValueDef (CORBA::tk_objref, sizeof (_oc_IR_ValueDef), (char *) &_oc_IR_ValueDef, 0, sizeof (IR::ValueDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDef, &_tc_TAO_tc_IR_ValueDef)
+TAO_NAMESPACE_END
+static const CORBA::Long _oc_IR_ValueDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDescription:1.0
+  17, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ValueDescription
   15, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   12, ACE_NTOHL (0x69735f61), ACE_NTOHL (0x62737472), ACE_NTOHL (0x61637400),  // name = is_abstract
   CORBA::tk_boolean,
@@ -12678,71 +28009,95 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
   11, ACE_NTOHL (0x6f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e730000),  // name = operations
   CORBA::tk_alias, // typecode kind for typedefs
-  2036, // encapsulation length
+  2532, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OpDescriptionSeq:1.0
+    36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OpDescriptionSeq:1.0
     17, ACE_NTOHL (0x4f704465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x0),  // name = OpDescriptionSeq
     CORBA::tk_sequence, // typecode kind
-    1956, // encapsulation length
+    2456, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_struct, // typecode kind
-      1940, // encapsulation length
+      2440, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/OperationDescription:1.0
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
         21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
         9, // member count
         5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        132, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
           11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
 
         3, ACE_NTOHL (0x69640000),  // name = id
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        64, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
           12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string,
+          CORBA::tk_string, 
           0U, // string length
 
         7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
@@ -12752,7 +28107,7 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
         CORBA::tk_enum, // typecode kind
         100, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4f70), ACE_NTOHL (0x65726174), ACE_NTOHL (0x696f6e4d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/OperationMode:1.0
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
           14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
           2, // member count
           10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
@@ -12760,25 +28115,31 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
 
         9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
         CORBA::tk_alias, // typecode kind for typedefs
-        236, // encapsulation length
+        296, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ContextIdSeq:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
           13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
           CORBA::tk_sequence, // typecode kind
-          164, // encapsulation length
+          228, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
             CORBA::tk_alias, // typecode kind for typedefs
-            148, // encapsulation length
+            212, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f436f), ACE_NTOHL (0x6e746578), ACE_NTOHL (0x74496465), ACE_NTOHL (0x6e746966), ACE_NTOHL (0x6965723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ContextIdentifier:1.0
+              37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
               18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
               CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
+              132, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
                 11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
 
             0U,
@@ -12786,43 +28147,49 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
 
         11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
         CORBA::tk_alias, // typecode kind for typedefs
-        496, // encapsulation length
+        552, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParDescriptionSeq:1.0
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
           18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
           CORBA::tk_sequence, // typecode kind
-          416, // encapsulation length
+          472, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
             CORBA::tk_struct, // typecode kind
-            400, // encapsulation length
+            456, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x74657244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ParameterDescription:1.0
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
               21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
               4, // member count
               5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
               CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
+              132, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
                 11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
               5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
               CORBA::tk_TypeCode,
 
               9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
               CORBA::tk_objref, // typecode kind
-              52, // encapsulation length
+              48, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+                27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
                 8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
               5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
               CORBA::tk_enum, // typecode kind
               116, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5061), ACE_NTOHL (0x72616d65), ACE_NTOHL (0x7465724d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ParameterMode:1.0
+                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
                 14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
                 3, // member count
                 9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
@@ -12835,53 +28202,71 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
 
         11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
         CORBA::tk_alias, // typecode kind for typedefs
-        556, // encapsulation length
+        748, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ExcDescriptionSeq:1.0
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
           18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
           CORBA::tk_sequence, // typecode kind
-          476, // encapsulation length
+          668, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
             CORBA::tk_struct, // typecode kind
-            460, // encapsulation length
+            652, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4578), ACE_NTOHL (0x63657074), ACE_NTOHL (0x696f6e44), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ExceptionDescription:1.0
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
               21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
               5, // member count
               5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
               CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
+              132, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
                 11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
               3, ACE_NTOHL (0x69640000),  // name = id
               CORBA::tk_alias, // typecode kind for typedefs
-              72, // encapsulation length
+              140, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
                 13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
               11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
               CORBA::tk_alias, // typecode kind for typedefs
-              72, // encapsulation length
+              140, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
                 13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
               8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
               CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
+              64, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
                 12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-                CORBA::tk_string,
+                CORBA::tk_string, 
                 0U, // string length
 
               5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -12897,53 +28282,71 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
 
   11, ACE_NTOHL (0x61747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65730000),  // name = attributes
   CORBA::tk_alias, // typecode kind for typedefs
-  684, // encapsulation length
+  2424, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/AttrDescriptionSeq:1.0
+    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
     19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
     CORBA::tk_sequence, // typecode kind
-    600, // encapsulation length
+    2344, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_struct, // typecode kind
-      584, // encapsulation length
+      2328, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        43, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x75746544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/AttributeDescription:1.0
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
         21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
-        6, // member count
+        8, // member count
         5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        132, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
           11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
 
         3, ACE_NTOHL (0x69640000),  // name = id
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        64, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
           12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string,
+          CORBA::tk_string, 
           0U, // string length
 
         5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -12953,65 +28356,235 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
         CORBA::tk_enum, // typecode kind
         104, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4174), ACE_NTOHL (0x74726962), ACE_NTOHL (0x7574654d), ACE_NTOHL (0x6f64653a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/AttributeMode:1.0
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
           14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
           2, // member count
           12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
           14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
 
+        15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        748, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          668, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            652, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              3, ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              64, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
+        15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        748, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          668, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            652, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              3, ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              64, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
 
       0U,
 
 
   8, ACE_NTOHL (0x6d656d62), ACE_NTOHL (0x65727300),  // name = members
   CORBA::tk_alias, // typecode kind for typedefs
-  692, // encapsulation length
+  876, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c75654d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x72536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/ValueMemberSeq:1.0
+    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ValueMemberSeq:1.0
     15, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65710000),  // name = ValueMemberSeq
     CORBA::tk_sequence, // typecode kind
-    616, // encapsulation length
+    804, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_struct, // typecode kind
-      600, // encapsulation length
+      788, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c75654d), ACE_NTOHL (0x656d6265), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueMember:1.0
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueMember:1.0
         12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d656d), ACE_NTOHL (0x62657200),  // name = ValueMember
         7, // member count
         5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        132, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
           11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
 
         3, ACE_NTOHL (0x69640000),  // name = id
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
         CORBA::tk_alias, // typecode kind for typedefs
-        72, // encapsulation length
+        140, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
           13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-          CORBA::tk_string,
-          0U, // string length
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
 
         8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
         CORBA::tk_alias, // typecode kind for typedefs
-        68, // encapsulation length
+        64, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
           12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-          CORBA::tk_string,
+          CORBA::tk_string, 
           0U, // string length
 
         5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
@@ -13019,9 +28592,9 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
 
         9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
         CORBA::tk_objref, // typecode kind
-        52, // encapsulation length
+        48, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+          27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
           8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
         7, ACE_NTOHL (0x61636365), ACE_NTOHL (0x73730000),  // name = access
@@ -13039,97 +28612,130 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
 
   13, ACE_NTOHL (0x696e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657273), ACE_NTOHL (0x0),  // name = initializers
   CORBA::tk_alias, // typecode kind for typedefs
-  516, // encapsulation length
+  712, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x69746961), ACE_NTOHL (0x6c697a65), ACE_NTOHL (0x72536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/InitializerSeq:1.0
+    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/InitializerSeq:1.0
     15, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657253), ACE_NTOHL (0x65710000),  // name = InitializerSeq
     CORBA::tk_sequence, // typecode kind
-    440, // encapsulation length
+    640, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_struct, // typecode kind
-      424, // encapsulation length
+      624, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f496e), ACE_NTOHL (0x69746961), ACE_NTOHL (0x6c697a65), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/Initializer:1.0
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e697469), ACE_NTOHL (0x616c697a), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/Initializer:1.0
         12, ACE_NTOHL (0x496e6974), ACE_NTOHL (0x69616c69), ACE_NTOHL (0x7a657200),  // name = Initializer
-        1, // member count
+        2, // member count
         8, ACE_NTOHL (0x6d656d62), ACE_NTOHL (0x65727300),  // name = members
         CORBA::tk_alias, // typecode kind for typedefs
-        340, // encapsulation length
+        392, // encapsulation length
           TAO_ENCAP_BYTE_ORDER, // byte order
-          38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65725365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/StructMemberSeq:1.0
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x62657253), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/StructMemberSeq:1.0
           16, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x53657100),  // name = StructMemberSeq
           CORBA::tk_sequence, // typecode kind
-          264, // encapsulation length
+          320, // encapsulation length
             TAO_ENCAP_BYTE_ORDER, // byte order
             CORBA::tk_struct, // typecode kind
-            248, // encapsulation length
+            304, // encapsulation length
               TAO_ENCAP_BYTE_ORDER, // byte order
-              35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5374), ACE_NTOHL (0x72756374), ACE_NTOHL (0x4d656d62), ACE_NTOHL (0x65723a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/StructMember:1.0
+              32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f53), ACE_NTOHL (0x74727563), ACE_NTOHL (0x744d656d), ACE_NTOHL (0x6265723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/StructMember:1.0
               13, ACE_NTOHL (0x53747275), ACE_NTOHL (0x63744d65), ACE_NTOHL (0x6d626572), ACE_NTOHL (0x0),  // name = StructMember
               3, // member count
               5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
               CORBA::tk_alias, // typecode kind for typedefs
-              68, // encapsulation length
+              132, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
                 11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-                CORBA::tk_string,
-                0U, // string length
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
 
               5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
               CORBA::tk_TypeCode,
 
               9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
               CORBA::tk_objref, // typecode kind
-              52, // encapsulation length
+              48, // encapsulation length
                 TAO_ENCAP_BYTE_ORDER, // byte order
-                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4944), ACE_NTOHL (0x4c547970), ACE_NTOHL (0x653a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/IDLType:1.0
+                27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
                 8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
 
 
             0U,
 
 
+        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        132, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
+
 
       0U,
 
 
   21, ACE_NTOHL (0x73757070), ACE_NTOHL (0x6f727465), ACE_NTOHL (0x645f696e), ACE_NTOHL (0x74657266), ACE_NTOHL (0x61636573), ACE_NTOHL (0x0),  // name = supported_interfaces
   CORBA::tk_alias, // typecode kind for typedefs
-  164, // encapsulation length
+  228, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49645365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
     16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
     CORBA::tk_sequence, // typecode kind
-    88, // encapsulation length
+    156, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       0U,
 
 
   21, ACE_NTOHL (0x61627374), ACE_NTOHL (0x72616374), ACE_NTOHL (0x5f626173), ACE_NTOHL (0x655f7661), ACE_NTOHL (0x6c756573), ACE_NTOHL (0x0),  // name = abstract_base_values
   CORBA::tk_alias, // typecode kind for typedefs
-  164, // encapsulation length
+  228, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49645365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
     16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
     CORBA::tk_sequence, // typecode kind
-    88, // encapsulation length
+    156, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       0U,
 
@@ -13139,314 +28745,4634 @@ static const CORBA::Long _oc_CORBA_ValueDef_FullValueDescription[] =
 
   11, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f76616c), ACE_NTOHL (0x75650000),  // name = base_value
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
   CORBA::tk_TypeCode,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueDef_FullValueDescription (CORBA::tk_struct, sizeof (_oc_CORBA_ValueDef_FullValueDescription), (char *) &_oc_CORBA_ValueDef_FullValueDescription, 0, sizeof (CORBA_ValueDef::FullValueDescription));
-CORBA::TypeCode_ptr CORBA_ValueDef::_tc_FullValueDescription = &_tc_TAO_tc_CORBA_ValueDef_FullValueDescription;
+static CORBA::TypeCode _tc_TAO_tc_IR_ValueDescription (CORBA::tk_struct, sizeof (_oc_IR_ValueDescription), (char *) &_oc_IR_ValueDescription, 0, sizeof (IR::ValueDescription));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDescription, &_tc_TAO_tc_IR_ValueDescription)
+TAO_NAMESPACE_END
+void IR::ValueDescription::_tao_any_destructor (void *x)
+{
+  ValueDescription *tmp = ACE_static_cast (ValueDescription*,x);
+  delete tmp;
+}
+
+void IR::ValueBoxDef::_tao_any_destructor (void *x)
+{
+  ValueBoxDef *tmp = ACE_static_cast (ValueBoxDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ValueBoxDef_ptr IR::ValueBoxDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ValueBoxDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ValueBoxDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ValueBoxDef::_nil ());
+  if (is_a == 0)
+    return ValueBoxDef::_nil ();
+  return ValueBoxDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
 
-CORBA_ValueDef::FullValueDescription * CORBA_ValueDef::describe_value (
-    CORBA_Environment &ACE_TRY_ENV
+IR::ValueBoxDef_ptr IR::ValueBoxDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ValueBoxDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  ValueBoxDef_ptr default_proxy = ValueBoxDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ValueBoxDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_ValueBoxDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ValueBoxDef (stub), ValueBoxDef::_nil ());
+  return TAO_IR_ValueBoxDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::ValueBoxDef_ptr 
+IR::ValueBoxDef::_duplicate (ValueBoxDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+IR::IDLType_ptr IR::ValueBoxDef::original_type_def (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+  IR::IDLType_ptr _tao_retval = IR::IDLType::_nil ();
+  IR::IDLType_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_original_type_def",
+      22,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  CORBA_ValueDef::FullValueDescription* _tao_retval = 0;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_original_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_original_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_original_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+void IR::ValueBoxDef::original_type_def (
+    IR::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW (CORBA::INTERNAL ());
 
-
-  ACE_NEW_RETURN (_tao_retval, CORBA_ValueDef::FullValueDescription, _tao_retval);
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "describe_value",
-      14,
+      "_set_original_type_def",
+      22,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_original_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << original_type_def)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_original_type_def",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_original_type_def",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+}
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+CORBA::Boolean IR::ValueBoxDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ValueBoxDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/TypedefDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::ValueBoxDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ValueBoxDef:1.0";
+}
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+IR::TAO_IR_ValueBoxDef_Default_Proxy_Factory::TAO_IR_ValueBoxDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+      TAO_IR_ValueBoxDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ValueBoxDef_Default_Proxy_Factory::~TAO_IR_ValueBoxDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ValueBoxDef_ptr
+IR::TAO_IR_ValueBoxDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ValueBoxDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ValueBoxDef_Proxy_Factory_Adapter::TAO_IR_ValueBoxDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ValueBoxDef_Proxy_Factory_Adapter::~TAO_IR_ValueBoxDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ValueBoxDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ValueBoxDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
 
+int
+IR::TAO_IR_ValueBoxDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
     }
-    break;
+return 0;
+}
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> *_tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+IR::ValueBoxDef_ptr
+IR::TAO_IR_ValueBoxDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ValueBoxDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ValueBoxDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
 }
 
-CORBA_ValueMemberDef_ptr CORBA_ValueDef::create_value_member (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA_IDLType_ptr type,
-    CORBA::Visibility access,
-    CORBA_Environment &ACE_TRY_ENV
+IR::TAO_IR_ValueBoxDef_Smart_Proxy_Base::TAO_IR_ValueBoxDef_Smart_Proxy_Base (::IR::ValueBoxDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ValueBoxDef_Smart_Proxy_Base::~TAO_IR_ValueBoxDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ValueBoxDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::IDLType_ptr IR::TAO_IR_ValueBoxDef_Smart_Proxy_Base::original_type_def  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->original_type_def (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_ValueBoxDef_Smart_Proxy_Base::original_type_def  (
+    IR::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  this->base_proxy_->original_type_def (
+      original_type_def,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ValueBoxDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ValueBoxDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ValueBoxDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x426f7844), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ValueBoxDef:1.0
+  12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65426f78), ACE_NTOHL (0x44656600),  // name = ValueBoxDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ValueBoxDef (CORBA::tk_objref, sizeof (_oc_IR_ValueBoxDef), (char *) &_oc_IR_ValueBoxDef, 0, sizeof (IR::ValueBoxDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueBoxDef, &_tc_TAO_tc_IR_ValueBoxDef)
+TAO_NAMESPACE_END
+void IR::ProvidesDef::_tao_any_destructor (void *x)
+{
+  ProvidesDef *tmp = ACE_static_cast (ProvidesDef*,x);
+  CORBA::release (tmp);
+}
 
-  CORBA_ValueMemberDef_ptr _tao_retval = CORBA_ValueMemberDef::_nil ();
+IR::ProvidesDef_ptr IR::ProvidesDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ProvidesDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ProvidesDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ProvidesDef::_nil ());
+  if (is_a == 0)
+    return ProvidesDef::_nil ();
+  return ProvidesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
 
+IR::ProvidesDef_ptr IR::ProvidesDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ProvidesDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  ProvidesDef_ptr default_proxy = ProvidesDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ProvidesDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_ProvidesDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ProvidesDef (stub), ProvidesDef::_nil ());
+  return TAO_IR_ProvidesDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
 
+IR::ProvidesDef_ptr 
+IR::ProvidesDef::_duplicate (ProvidesDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+IR::InterfaceDef_ptr IR::ProvidesDef::interface_type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::InterfaceDef_ptr _tao_retval = IR::InterfaceDef::_nil ();
+  IR::InterfaceDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_interface_type",
+      19,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_interface_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_interface_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_interface_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Boolean IR::ProvidesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ProvidesDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::ProvidesDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ProvidesDef:1.0";
+}
+
+IR::TAO_IR_ProvidesDef_Default_Proxy_Factory::TAO_IR_ProvidesDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_ProvidesDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ProvidesDef_Default_Proxy_Factory::~TAO_IR_ProvidesDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ProvidesDef_ptr
+IR::TAO_IR_ProvidesDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ProvidesDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ProvidesDef_Proxy_Factory_Adapter::TAO_IR_ProvidesDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ProvidesDef_Proxy_Factory_Adapter::~TAO_IR_ProvidesDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ProvidesDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ProvidesDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ProvidesDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::ProvidesDef_ptr
+IR::TAO_IR_ProvidesDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ProvidesDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ProvidesDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_ProvidesDef_Smart_Proxy_Base::TAO_IR_ProvidesDef_Smart_Proxy_Base (::IR::ProvidesDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ProvidesDef_Smart_Proxy_Base::~TAO_IR_ProvidesDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ProvidesDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::InterfaceDef_ptr IR::TAO_IR_ProvidesDef_Smart_Proxy_Base::interface_type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->interface_type (
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ProvidesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ProvidesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ProvidesDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDef:1.0
+  12, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656600),  // name = ProvidesDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDef (CORBA::tk_objref, sizeof (_oc_IR_ProvidesDef), (char *) &_oc_IR_ProvidesDef, 0, sizeof (IR::ProvidesDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDef, &_tc_TAO_tc_IR_ProvidesDef)
+TAO_NAMESPACE_END
+static const CORBA::Long _oc_IR_ProvidesDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDescription:1.0
+  20, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = ProvidesDescription
+  5, // member count
+  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  132, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  3, ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  15, ACE_NTOHL (0x696e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x655f7479), ACE_NTOHL (0x70650000),  // name = interface_type
+  CORBA::tk_objref, // typecode kind
+  60, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
+    13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = InterfaceDef
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDescription (CORBA::tk_struct, sizeof (_oc_IR_ProvidesDescription), (char *) &_oc_IR_ProvidesDescription, 0, sizeof (IR::ProvidesDescription));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDescription, &_tc_TAO_tc_IR_ProvidesDescription)
+TAO_NAMESPACE_END
+void IR::ProvidesDescription::_tao_any_destructor (void *x)
+{
+  ProvidesDescription *tmp = ACE_static_cast (ProvidesDescription*,x);
+  delete tmp;
+}
+
+void IR::UsesDef::_tao_any_destructor (void *x)
+{
+  UsesDef *tmp = ACE_static_cast (UsesDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::UsesDef_ptr IR::UsesDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return UsesDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/UsesDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (UsesDef::_nil ());
+  if (is_a == 0)
+    return UsesDef::_nil ();
+  return UsesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
 
+IR::UsesDef_ptr IR::UsesDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return UsesDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  UsesDef_ptr default_proxy = UsesDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_UsesDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_UsesDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, UsesDef (stub), UsesDef::_nil ());
+  return TAO_IR_UsesDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
 
+IR::UsesDef_ptr 
+IR::UsesDef::_duplicate (UsesDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+IR::InterfaceDef_ptr IR::UsesDef::interface_type (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::InterfaceDef_ptr _tao_retval = IR::InterfaceDef::_nil ();
+  IR::InterfaceDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "create_value_member",
+      "_get_interface_type",
       19,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_interface_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_interface_type",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_interface_type",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+CORBA::Boolean IR::UsesDef::is_multiple (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << type) &&
-          (_tao_out << access)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_multiple",
+      16,
+      istub->orb_core ()
+    );
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_multiple",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_multiple",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_is_multiple",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_retval;
+}
 
+CORBA::Boolean IR::UsesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/UsesDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::UsesDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/UsesDef:1.0";
+}
+
+IR::TAO_IR_UsesDef_Default_Proxy_Factory::TAO_IR_UsesDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_UsesDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
     }
-    break;
+}
+
+IR::TAO_IR_UsesDef_Default_Proxy_Factory::~TAO_IR_UsesDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::UsesDef_ptr
+IR::TAO_IR_UsesDef_Default_Proxy_Factory::create_proxy (
+    ::IR::UsesDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_UsesDef_Proxy_Factory_Adapter::TAO_IR_UsesDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_UsesDef_Proxy_Factory_Adapter::~TAO_IR_UsesDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_UsesDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_UsesDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_UsesDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::UsesDef_ptr
+IR::TAO_IR_UsesDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::UsesDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_UsesDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_UsesDef_Smart_Proxy_Base::TAO_IR_UsesDef_Smart_Proxy_Base (::IR::UsesDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_UsesDef_Smart_Proxy_Base::~TAO_IR_UsesDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_UsesDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::InterfaceDef_ptr IR::TAO_IR_UsesDef_Smart_Proxy_Base::interface_type  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->interface_type (
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::Boolean IR::TAO_IR_UsesDef_Smart_Proxy_Base::is_multiple  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_multiple (
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_UsesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_UsesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_UsesDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDef:1.0
+  8, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656600),  // name = UsesDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_UsesDef (CORBA::tk_objref, sizeof (_oc_IR_UsesDef), (char *) &_oc_IR_UsesDef, 0, sizeof (IR::UsesDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDef, &_tc_TAO_tc_IR_UsesDef)
+TAO_NAMESPACE_END
+static const CORBA::Long _oc_IR_UsesDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDescription:1.0
+  16, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = UsesDescription
+  6, // member count
+  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  132, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  3, ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  15, ACE_NTOHL (0x696e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x655f7479), ACE_NTOHL (0x70650000),  // name = interface_type
+  CORBA::tk_objref, // typecode kind
+  60, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
+    13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = InterfaceDef
+
+  12, ACE_NTOHL (0x69735f6d), ACE_NTOHL (0x756c7469), ACE_NTOHL (0x706c6500),  // name = is_multiple
+  CORBA::tk_boolean,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_UsesDescription (CORBA::tk_struct, sizeof (_oc_IR_UsesDescription), (char *) &_oc_IR_UsesDescription, 0, sizeof (IR::UsesDescription));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDescription, &_tc_TAO_tc_IR_UsesDescription)
+TAO_NAMESPACE_END
+void IR::UsesDescription::_tao_any_destructor (void *x)
+{
+  UsesDescription *tmp = ACE_static_cast (UsesDescription*,x);
+  delete tmp;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CS_
+
+  void
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::ProvidesDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::ProvidesDescription *old = ACE_reinterpret_cast (IR::ProvidesDescription *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
+  }
+  
+  void
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    IR::ProvidesDescription *tmp = ACE_reinterpret_cast (IR::ProvidesDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::~_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDESCSEQ_CS_)
+#define _IR_PROVIDESDESCSEQ_CS_
+
+// *************************************************************
+// IR::ProvidesDescSeq
+// *************************************************************
+
+IR::ProvidesDescSeq::ProvidesDescSeq (void)
+{}
+IR::ProvidesDescSeq::ProvidesDescSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ProvidesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::ProvidesDescSeq::ProvidesDescSeq (CORBA::ULong max, CORBA::ULong length, IR::ProvidesDescription *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ProvidesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::ProvidesDescSeq::ProvidesDescSeq (const ProvidesDescSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::ProvidesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::ProvidesDescSeq::~ProvidesDescSeq (void) // dtor
+{}
+void IR::ProvidesDescSeq::_tao_any_destructor (void *x)
+{
+  ProvidesDescSeq *tmp = ACE_static_cast (ProvidesDescSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_ProvidesDescSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65736353), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDescSeq:1.0
+  16, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x53657100),  // name = ProvidesDescSeq
+  CORBA::tk_sequence, // typecode kind
+  736, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    720, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDescription:1.0
+      20, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = ProvidesDescription
+      5, // member count
+      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      132, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      3, ACE_NTOHL (0x69640000),  // name = id
+      CORBA::tk_alias, // typecode kind for typedefs
+      140, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+      CORBA::tk_alias, // typecode kind for typedefs
+      140, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+      CORBA::tk_alias, // typecode kind for typedefs
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+        CORBA::tk_string, 
+        0U, // string length
+
+      15, ACE_NTOHL (0x696e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x655f7479), ACE_NTOHL (0x70650000),  // name = interface_type
+      CORBA::tk_objref, // typecode kind
+      60, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
+        13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = InterfaceDef
 
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ProvidesDescSeq (CORBA::tk_alias, sizeof (_oc_IR_ProvidesDescSeq), (char *) &_oc_IR_ProvidesDescSeq, 0, sizeof (IR::ProvidesDescSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ProvidesDescSeq, &_tc_TAO_tc_IR_ProvidesDescSeq)
+TAO_NAMESPACE_END
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CS_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CS_
+
+  void
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_allocate_buffer (CORBA::ULong length)
+  {
+    IR::UsesDescription* tmp = 0;
+    tmp = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (length);
+    
+    if (this->buffer_ != 0)
+    {
+      IR::UsesDescription *old = ACE_reinterpret_cast (IR::UsesDescription *,this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp[i] = old[i];
+      
+      if (this->release_)
+        _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (old);
+      
+    }
+    this->buffer_ = tmp;
   }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+  
+  void
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_deallocate_buffer (void)
+  {
+    if (this->buffer_ == 0 || this->release_ == 0)
+      return;
+    
+    IR::UsesDescription *tmp = ACE_reinterpret_cast (IR::UsesDescription *,this->buffer_);
+    
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (tmp);
+    this->buffer_ = 0;
+  } 
+  
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::~_TAO_Unbounded_Sequence_IR_UsesDescSeq (void) // Dtor.
+  {
+    this->_deallocate_buffer ();
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_USESDESCSEQ_CS_)
+#define _IR_USESDESCSEQ_CS_
+
+// *************************************************************
+// IR::UsesDescSeq
+// *************************************************************
+
+IR::UsesDescSeq::UsesDescSeq (void)
+{}
+IR::UsesDescSeq::UsesDescSeq (CORBA::ULong max) // uses max size
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_UsesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::UsesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max)
+{}
+IR::UsesDescSeq::UsesDescSeq (CORBA::ULong max, CORBA::ULong length, IR::UsesDescription *buffer, CORBA::Boolean release)
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_UsesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::UsesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (max, length, buffer, release)
+{}
+IR::UsesDescSeq::UsesDescSeq (const UsesDescSeq &seq) // copy ctor
+  : 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_UsesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<IR::UsesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+ (seq)
+{}
+IR::UsesDescSeq::~UsesDescSeq (void) // dtor
+{}
+void IR::UsesDescSeq::_tao_any_destructor (void *x)
+{
+  UsesDescSeq *tmp = ACE_static_cast (UsesDescSeq*,x);
+  delete tmp;
+}
+
+
+#endif /* end #if !defined */
+
+static const CORBA::Long _oc_IR_UsesDescSeq[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65736353), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDescSeq:1.0
+  12, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x53657100),  // name = UsesDescSeq
+  CORBA::tk_sequence, // typecode kind
+  748, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    CORBA::tk_struct, // typecode kind
+    732, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDescription:1.0
+      16, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = UsesDescription
+      6, // member count
+      5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+      CORBA::tk_alias, // typecode kind for typedefs
+      132, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+        11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+        CORBA::tk_alias, // typecode kind for typedefs
+        68, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      3, ACE_NTOHL (0x69640000),  // name = id
+      CORBA::tk_alias, // typecode kind for typedefs
+      140, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+      CORBA::tk_alias, // typecode kind for typedefs
+      140, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+        13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
+
+      8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+      CORBA::tk_alias, // typecode kind for typedefs
+      64, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+        12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+        CORBA::tk_string, 
+        0U, // string length
+
+      15, ACE_NTOHL (0x696e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x655f7479), ACE_NTOHL (0x70650000),  // name = interface_type
+      CORBA::tk_objref, // typecode kind
+      60, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x6e746572), ACE_NTOHL (0x66616365), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/InterfaceDef:1.0
+        13, ACE_NTOHL (0x496e7465), ACE_NTOHL (0x72666163), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = InterfaceDef
+
+      12, ACE_NTOHL (0x69735f6d), ACE_NTOHL (0x756c7469), ACE_NTOHL (0x706c6500),  // name = is_multiple
+      CORBA::tk_boolean,
+
+
+    0U,
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_UsesDescSeq (CORBA::tk_alias, sizeof (_oc_IR_UsesDescSeq), (char *) &_oc_IR_UsesDescSeq, 0, sizeof (IR::UsesDescSeq));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_UsesDescSeq, &_tc_TAO_tc_IR_UsesDescSeq)
+TAO_NAMESPACE_END
+void IR::EventDef::_tao_any_destructor (void *x)
+{
+  EventDef *tmp = ACE_static_cast (EventDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::EventDef_ptr IR::EventDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return EventDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/EventDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (EventDef::_nil ());
+  if (is_a == 0)
+    return EventDef::_nil ();
+  return EventDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::EventDef_ptr IR::EventDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return EventDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  EventDef_ptr default_proxy = EventDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_EventDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_EventDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, EventDef (stub), EventDef::_nil ());
+  return TAO_IR_EventDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::EventDef_ptr 
+IR::EventDef::_duplicate (EventDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+CORBA::Boolean IR::EventDef::is_a (
+    const char * event_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "is_a",
+      4,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "is_a",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << event_id)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "is_a",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "is_a",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-CORBA_AttributeDef_ptr CORBA_ValueDef::create_attribute (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA_IDLType_ptr type,
-    CORBA::AttributeMode mode,
-    CORBA_Environment &ACE_TRY_ENV
+IR::ValueDef_ptr IR::EventDef::event (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+  IR::ValueDef_ptr _tao_retval = IR::ValueDef::_nil ();
+  IR::ValueDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_event",
+      10,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_event",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_event",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_event",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Boolean IR::EventDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::EventDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/EventDef:1.0";
+}
+
+IR::TAO_IR_EventDef_Default_Proxy_Factory::TAO_IR_EventDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_EventDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_EventDef_Default_Proxy_Factory::~TAO_IR_EventDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::EventDef_ptr
+IR::TAO_IR_EventDef_Default_Proxy_Factory::create_proxy (
+    ::IR::EventDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
 
-  CORBA_AttributeDef_ptr _tao_retval = CORBA_AttributeDef::_nil ();
+IR::TAO_IR_EventDef_Proxy_Factory_Adapter::TAO_IR_EventDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
 
+IR::TAO_IR_EventDef_Proxy_Factory_Adapter::~TAO_IR_EventDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
 
+int
+IR::TAO_IR_EventDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_EventDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_EventDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::EventDef_ptr
+IR::TAO_IR_EventDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::EventDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_EventDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_EventDef_Smart_Proxy_Base::TAO_IR_EventDef_Smart_Proxy_Base (::IR::EventDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_EventDef_Smart_Proxy_Base::~TAO_IR_EventDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_EventDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::Boolean IR::TAO_IR_EventDef_Smart_Proxy_Base::is_a  (
+    const char * event_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_a (
+      event_id,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ValueDef_ptr IR::TAO_IR_EventDef_Smart_Proxy_Base::event  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->event (
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_EventDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_EventDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_EventDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x76656e74), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EventDef:1.0
+  9, ACE_NTOHL (0x4576656e), ACE_NTOHL (0x74446566), ACE_NTOHL (0x0),  // name = EventDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_EventDef (CORBA::tk_objref, sizeof (_oc_IR_EventDef), (char *) &_oc_IR_EventDef, 0, sizeof (IR::EventDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EventDef, &_tc_TAO_tc_IR_EventDef)
+TAO_NAMESPACE_END
+static const CORBA::Long _oc_IR_EventDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x76656e74), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EventDescription:1.0
+  17, ACE_NTOHL (0x4576656e), ACE_NTOHL (0x74446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = EventDescription
+  5, // member count
+  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  132, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  3, ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  6, ACE_NTOHL (0x76616c75), ACE_NTOHL (0x65000000),  // name = value
+  CORBA::tk_objref, // typecode kind
+  52, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDef:1.0
+    9, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = ValueDef
+
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_EventDescription (CORBA::tk_struct, sizeof (_oc_IR_EventDescription), (char *) &_oc_IR_EventDescription, 0, sizeof (IR::EventDescription));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EventDescription, &_tc_TAO_tc_IR_EventDescription)
+TAO_NAMESPACE_END
+void IR::EventDescription::_tao_any_destructor (void *x)
+{
+  EventDescription *tmp = ACE_static_cast (EventDescription*,x);
+  delete tmp;
+}
+
+void IR::EmitsDef::_tao_any_destructor (void *x)
+{
+  EmitsDef *tmp = ACE_static_cast (EmitsDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::EmitsDef_ptr IR::EmitsDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return EmitsDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/EmitsDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (EmitsDef::_nil ());
+  if (is_a == 0)
+    return EmitsDef::_nil ();
+  return EmitsDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::EmitsDef_ptr IR::EmitsDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return EmitsDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  EmitsDef_ptr default_proxy = EmitsDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_EmitsDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_EmitsDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, EmitsDef (stub), EmitsDef::_nil ());
+  return TAO_IR_EmitsDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::EmitsDef_ptr 
+IR::EmitsDef::_duplicate (EmitsDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+CORBA::Boolean IR::EmitsDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EmitsDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::EmitsDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/EmitsDef:1.0";
+}
+
+IR::TAO_IR_EmitsDef_Default_Proxy_Factory::TAO_IR_EmitsDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_EmitsDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_EmitsDef_Default_Proxy_Factory::~TAO_IR_EmitsDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::EmitsDef_ptr
+IR::TAO_IR_EmitsDef_Default_Proxy_Factory::create_proxy (
+    ::IR::EmitsDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_EmitsDef_Proxy_Factory_Adapter::TAO_IR_EmitsDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_EmitsDef_Proxy_Factory_Adapter::~TAO_IR_EmitsDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_EmitsDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_EmitsDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_EmitsDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::EmitsDef_ptr
+IR::TAO_IR_EmitsDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::EmitsDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_EmitsDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_EmitsDef_Smart_Proxy_Base::TAO_IR_EmitsDef_Smart_Proxy_Base (::IR::EmitsDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_EmitsDef_Smart_Proxy_Base::~TAO_IR_EmitsDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_EmitsDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_EmitsDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_EmitsDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_EmitsDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EmitsDef:1.0
+  9, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = EmitsDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_EmitsDef (CORBA::tk_objref, sizeof (_oc_IR_EmitsDef), (char *) &_oc_IR_EmitsDef, 0, sizeof (IR::EmitsDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_EmitsDef, &_tc_TAO_tc_IR_EmitsDef)
+TAO_NAMESPACE_END
+void IR::PublishesDef::_tao_any_destructor (void *x)
+{
+  PublishesDef *tmp = ACE_static_cast (PublishesDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::PublishesDef_ptr IR::PublishesDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return PublishesDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/PublishesDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (PublishesDef::_nil ());
+  if (is_a == 0)
+    return PublishesDef::_nil ();
+  return PublishesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::PublishesDef_ptr IR::PublishesDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return PublishesDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  PublishesDef_ptr default_proxy = PublishesDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_PublishesDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_PublishesDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, PublishesDef (stub), PublishesDef::_nil ());
+  return TAO_IR_PublishesDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::PublishesDef_ptr 
+IR::PublishesDef::_duplicate (PublishesDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+CORBA::Boolean IR::PublishesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/PublishesDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::PublishesDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/PublishesDef:1.0";
+}
+
+IR::TAO_IR_PublishesDef_Default_Proxy_Factory::TAO_IR_PublishesDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_PublishesDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_PublishesDef_Default_Proxy_Factory::~TAO_IR_PublishesDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::PublishesDef_ptr
+IR::TAO_IR_PublishesDef_Default_Proxy_Factory::create_proxy (
+    ::IR::PublishesDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_PublishesDef_Proxy_Factory_Adapter::TAO_IR_PublishesDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_PublishesDef_Proxy_Factory_Adapter::~TAO_IR_PublishesDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_PublishesDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_PublishesDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_PublishesDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::PublishesDef_ptr
+IR::TAO_IR_PublishesDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::PublishesDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_PublishesDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_PublishesDef_Smart_Proxy_Base::TAO_IR_PublishesDef_Smart_Proxy_Base (::IR::PublishesDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_PublishesDef_Smart_Proxy_Base::~TAO_IR_PublishesDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_PublishesDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_PublishesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_PublishesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_PublishesDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PublishesDef:1.0
+  13, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = PublishesDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_PublishesDef (CORBA::tk_objref, sizeof (_oc_IR_PublishesDef), (char *) &_oc_IR_PublishesDef, 0, sizeof (IR::PublishesDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PublishesDef, &_tc_TAO_tc_IR_PublishesDef)
+TAO_NAMESPACE_END
+void IR::ConsumesDef::_tao_any_destructor (void *x)
+{
+  ConsumesDef *tmp = ACE_static_cast (ConsumesDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ConsumesDef_ptr IR::ConsumesDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ConsumesDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ConsumesDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ConsumesDef::_nil ());
+  if (is_a == 0)
+    return ConsumesDef::_nil ();
+  return ConsumesDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::ConsumesDef_ptr IR::ConsumesDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ConsumesDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  ConsumesDef_ptr default_proxy = ConsumesDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ConsumesDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_ConsumesDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ConsumesDef (stub), ConsumesDef::_nil ());
+  return TAO_IR_ConsumesDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::ConsumesDef_ptr 
+IR::ConsumesDef::_duplicate (ConsumesDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+CORBA::Boolean IR::ConsumesDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ConsumesDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/EventDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::ConsumesDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ConsumesDef:1.0";
+}
+
+IR::TAO_IR_ConsumesDef_Default_Proxy_Factory::TAO_IR_ConsumesDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_ConsumesDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ConsumesDef_Default_Proxy_Factory::~TAO_IR_ConsumesDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ConsumesDef_ptr
+IR::TAO_IR_ConsumesDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ConsumesDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ConsumesDef_Proxy_Factory_Adapter::TAO_IR_ConsumesDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ConsumesDef_Proxy_Factory_Adapter::~TAO_IR_ConsumesDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ConsumesDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ConsumesDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ConsumesDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::ConsumesDef_ptr
+IR::TAO_IR_ConsumesDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ConsumesDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ConsumesDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_ConsumesDef_Smart_Proxy_Base::TAO_IR_ConsumesDef_Smart_Proxy_Base (::IR::ConsumesDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ConsumesDef_Smart_Proxy_Base::~TAO_IR_ConsumesDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ConsumesDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ConsumesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ConsumesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ConsumesDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConsumesDef:1.0
+  12, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656600),  // name = ConsumesDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ConsumesDef (CORBA::tk_objref, sizeof (_oc_IR_ConsumesDef), (char *) &_oc_IR_ConsumesDef, 0, sizeof (IR::ConsumesDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ConsumesDef, &_tc_TAO_tc_IR_ConsumesDef)
+TAO_NAMESPACE_END
+void IR::ComponentDef::_tao_any_destructor (void *x)
+{
+  ComponentDef *tmp = ACE_static_cast (ComponentDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::ComponentDef_ptr IR::ComponentDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ComponentDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/ComponentDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (ComponentDef::_nil ());
+  if (is_a == 0)
+    return ComponentDef::_nil ();
+  return ComponentDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::ComponentDef_ptr IR::ComponentDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return ComponentDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  ComponentDef_ptr default_proxy = ComponentDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_ComponentDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_ComponentDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, ComponentDef (stub), ComponentDef::_nil ());
+  return TAO_IR_ComponentDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::ComponentDef_ptr 
+IR::ComponentDef::_duplicate (ComponentDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+IR::InterfaceDefSeq * IR::ComponentDef::supported_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::InterfaceDefSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
+  ACE_NEW_RETURN (_tao_retval, IR::InterfaceDefSeq, _tao_retval);
+  IR::InterfaceDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_supported_interfaces",
+      25,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_supported_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_supported_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_supported_interfaces",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+void IR::ComponentDef::supported_interfaces (
+    const IR::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW (CORBA::INTERNAL ());
+
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "create_attribute",
-      16,
+      "_set_supported_interfaces",
+      25,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK;
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK;
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_supported_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK;
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << supported_interfaces)
+          ))
+          TAO_INTERCEPTOR_THROW (CORBA::MARSHAL ());
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK;
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+        }
+        
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_set_supported_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK;
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_set_supported_interfaces",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK;
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+IR::ComponentDef_ptr IR::ComponentDef::base_component (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ComponentDef_ptr _tao_retval = IR::ComponentDef::_nil ();
+  IR::ComponentDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << type) &&
-          (_tao_out << mode)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_base_component",
+      19,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_base_component",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_base_component",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_base_component",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+IR::ProvidesDefSeq * IR::ComponentDef::provides_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ProvidesDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ProvidesDefSeq, _tao_retval);
+  IR::ProvidesDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_provides_interfaces",
+      24,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_provides_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_provides_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_provides_interfaces",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+IR::UsesDefSeq * IR::ComponentDef::uses_interfaces (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::UsesDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::UsesDefSeq, _tao_retval);
+  IR::UsesDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_uses_interfaces",
+      20,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_uses_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_uses_interfaces",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_uses_interfaces",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+IR::EmitsDefSeq * IR::ComponentDef::emits_events (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::EmitsDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::EmitsDefSeq, _tao_retval);
+  IR::EmitsDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_emits_events",
+      17,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_emits_events",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_emits_events",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_emits_events",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+IR::PublishesDefSeq * IR::ComponentDef::publishes_events (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::PublishesDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::PublishesDefSeq, _tao_retval);
+  IR::PublishesDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_publishes_events",
+      21,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_publishes_events",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_publishes_events",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_publishes_events",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+IR::ConsumesDefSeq * IR::ComponentDef::consumes_events (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ConsumesDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::ConsumesDefSeq, _tao_retval);
+  IR::ConsumesDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_consumes_events",
+      20,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_consumes_events",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_consumes_events",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_consumes_events",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Boolean IR::ComponentDef::is_basic (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_is_basic",
+      13,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_basic",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_basic",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_is_basic",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
   return _tao_retval;
 }
 
-CORBA_OperationDef_ptr CORBA_ValueDef::create_operation (
+IR::ProvidesDef_ptr IR::ComponentDef::create_provides (
     const char * id,
     const char * name,
     const char * version,
-    CORBA_IDLType_ptr result,
-    CORBA::OperationMode mode,
-    const CORBA_ParDescriptionSeq & params,
-    const CORBA_ExceptionDefSeq & exceptions,
-    const CORBA_ContextIdSeq & contexts,
-    CORBA_Environment &ACE_TRY_ENV
+    IR::InterfaceDef_ptr interface_type,
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+  IR::ProvidesDef_ptr _tao_retval = IR::ProvidesDef::_nil ();
+  IR::ProvidesDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_provides",
+      15,
+      istub->orb_core ()
+    );
 
-  CORBA_OperationDef_ptr _tao_retval = CORBA_OperationDef::_nil ();
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_provides",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << interface_type)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_provides",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_provides",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+IR::UsesDef_ptr IR::ComponentDef::create_uses (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::InterfaceDef_ptr interface_type,
+    CORBA::Boolean is_multiple,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::UsesDef_ptr _tao_retval = IR::UsesDef::_nil ();
+  IR::UsesDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "create_operation",
-      16,
+      "create_uses",
+      11,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_uses",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << interface_type) &&
+              (_tao_out << CORBA::Any::from_boolean (is_multiple))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_uses",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_uses",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    CORBA::Short flag = 131;
+IR::EmitsDef_ptr IR::ComponentDef::create_emits (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::EmitsDef_ptr _tao_retval = IR::EmitsDef::_nil ();
+  IR::EmitsDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_emits",
+      12,
+      istub->orb_core ()
+    );
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << id) &&
-          (_tao_out << name) &&
-          (_tao_out << version) &&
-          (_tao_out << result) &&
-          (_tao_out << mode) &&
-          (_tao_out << params) &&
-          (_tao_out << exceptions) &&
-          (_tao_out << contexts)
-      ))
-      ACE_THROW_RETURN (CORBA_MARSHAL (), _tao_retval);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_emits",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << value)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_emits",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_emits",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+IR::PublishesDef_ptr IR::ComponentDef::create_publishes (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::PublishesDef_ptr _tao_retval = IR::PublishesDef::_nil ();
+  IR::PublishesDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_publishes",
+      16,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_publishes",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << value)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_publishes",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_publishes",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+IR::ConsumesDef_ptr IR::ComponentDef::create_consumes (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ConsumesDef_ptr _tao_retval = IR::ConsumesDef::_nil ();
+  IR::ConsumesDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_consumes",
+      15,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_consumes",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << value)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_consumes",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_consumes",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA::Boolean CORBA_ValueDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::ComponentDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ValueDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/ComponentDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/InterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -13454,289 +33380,2865 @@ CORBA::Boolean CORBA_ValueDef::_is_a (const CORBA::Char *value, CORBA_Environmen
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_ValueDef::_interface_repository_id (void) const
+const char* IR::ComponentDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/ComponentDef:1.0";
+}
+
+IR::TAO_IR_ComponentDef_Default_Proxy_Factory::TAO_IR_ComponentDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_ComponentDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_ComponentDef_Default_Proxy_Factory::~TAO_IR_ComponentDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::ComponentDef_ptr
+IR::TAO_IR_ComponentDef_Default_Proxy_Factory::create_proxy (
+    ::IR::ComponentDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_ComponentDef_Proxy_Factory_Adapter::TAO_IR_ComponentDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_ComponentDef_Proxy_Factory_Adapter::~TAO_IR_ComponentDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_ComponentDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_ComponentDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_ComponentDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::ComponentDef_ptr
+IR::TAO_IR_ComponentDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::ComponentDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_ComponentDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_ComponentDef_Smart_Proxy_Base::TAO_IR_ComponentDef_Smart_Proxy_Base (::IR::ComponentDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_ComponentDef_Smart_Proxy_Base::~TAO_IR_ComponentDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_ComponentDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::InterfaceDefSeq * IR::TAO_IR_ComponentDef_Smart_Proxy_Base::supported_interfaces  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->supported_interfaces (
+      ACE_TRY_ENV
+    );
+
+}
+
+void IR::TAO_IR_ComponentDef_Smart_Proxy_Base::supported_interfaces  (
+    const IR::InterfaceDefSeq & supported_interfaces,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  this->base_proxy_->supported_interfaces (
+      supported_interfaces,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ComponentDef_ptr IR::TAO_IR_ComponentDef_Smart_Proxy_Base::base_component  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->base_component (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ProvidesDefSeq * IR::TAO_IR_ComponentDef_Smart_Proxy_Base::provides_interfaces  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->provides_interfaces (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::UsesDefSeq * IR::TAO_IR_ComponentDef_Smart_Proxy_Base::uses_interfaces  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->uses_interfaces (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::EmitsDefSeq * IR::TAO_IR_ComponentDef_Smart_Proxy_Base::emits_events  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->emits_events (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::PublishesDefSeq * IR::TAO_IR_ComponentDef_Smart_Proxy_Base::publishes_events  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->publishes_events (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ConsumesDefSeq * IR::TAO_IR_ComponentDef_Smart_Proxy_Base::consumes_events  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->consumes_events (
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::Boolean IR::TAO_IR_ComponentDef_Smart_Proxy_Base::is_basic  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  return "IDL:omg.org/CORBA/ValueDef:1.0";
+  return this->base_proxy_->is_basic (
+      ACE_TRY_ENV
+    );
+
 }
 
-static const CORBA::Long _oc_CORBA_ValueDef[] =
+IR::ProvidesDef_ptr IR::TAO_IR_ComponentDef_Smart_Proxy_Base::create_provides  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::InterfaceDef_ptr interface_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_provides (
+      id,
+      name,
+      version,
+      interface_type,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::UsesDef_ptr IR::TAO_IR_ComponentDef_Smart_Proxy_Base::create_uses  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::InterfaceDef_ptr interface_type,
+    CORBA::Boolean is_multiple,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_uses (
+      id,
+      name,
+      version,
+      interface_type,
+      is_multiple,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::EmitsDef_ptr IR::TAO_IR_ComponentDef_Smart_Proxy_Base::create_emits  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_emits (
+      id,
+      name,
+      version,
+      value,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::PublishesDef_ptr IR::TAO_IR_ComponentDef_Smart_Proxy_Base::create_publishes  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_publishes (
+      id,
+      name,
+      version,
+      value,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ConsumesDef_ptr IR::TAO_IR_ComponentDef_Smart_Proxy_Base::create_consumes  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ValueDef_ptr value,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_consumes (
+      id,
+      name,
+      version,
+      value,
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_ComponentDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_ComponentDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_ComponentDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c756544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ValueDef:1.0
-  9, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = ValueDef
+  32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ComponentDef:1.0
+  13, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74446566), ACE_NTOHL (0x0),  // name = ComponentDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueDef (CORBA::tk_objref, sizeof (_oc_CORBA_ValueDef), (char *) &_oc_CORBA_ValueDef, 0, sizeof (CORBA_ValueDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_ComponentDef (CORBA::tk_objref, sizeof (_oc_IR_ComponentDef), (char *) &_oc_IR_ComponentDef, 0, sizeof (IR::ComponentDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDef, &_tc_TAO_tc_CORBA_ValueDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentDef, &_tc_TAO_tc_IR_ComponentDef)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_ValueDescription[] =
+static const CORBA::Long _oc_IR_ComponentDescription[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  39, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c756544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/ValueDescription:1.0
-  17, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ValueDescription
-  10, // member count
+  40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6d706f), ACE_NTOHL (0x6e656e74), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ComponentDescription:1.0
+  21, ACE_NTOHL (0x436f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ComponentDescription
+  13, // member count
   5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
     11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
 
   3, ACE_NTOHL (0x69640000),  // name = id
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
-
-  12, ACE_NTOHL (0x69735f61), ACE_NTOHL (0x62737472), ACE_NTOHL (0x61637400),  // name = is_abstract
-  CORBA::tk_boolean,
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
 
-  10, ACE_NTOHL (0x69735f63), ACE_NTOHL (0x7573746f), ACE_NTOHL (0x6d000000),  // name = is_custom
-  CORBA::tk_boolean,
 
   11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
 
   8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
   CORBA::tk_alias, // typecode kind for typedefs
-  68, // encapsulation length
+  64, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5665), ACE_NTOHL (0x7273696f), ACE_NTOHL (0x6e537065), ACE_NTOHL (0x633a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/VersionSpec:1.0
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
     12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
-    CORBA::tk_string,
+    CORBA::tk_string, 
     0U, // string length
 
-  20, ACE_NTOHL (0x73757070), ACE_NTOHL (0x6f727465), ACE_NTOHL (0x645f696e), ACE_NTOHL (0x74657266), ACE_NTOHL (0x61636500),  // name = supported_interface
+  15, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f636f6d), ACE_NTOHL (0x706f6e65), ACE_NTOHL (0x6e740000),  // name = base_component
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  140, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
-    0U, // string length
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
 
-  21, ACE_NTOHL (0x61627374), ACE_NTOHL (0x72616374), ACE_NTOHL (0x5f626173), ACE_NTOHL (0x655f7661), ACE_NTOHL (0x6c756573), ACE_NTOHL (0x0),  // name = abstract_base_values
+
+  20, ACE_NTOHL (0x73757070), ACE_NTOHL (0x6f727473), ACE_NTOHL (0x5f696e74), ACE_NTOHL (0x65726661), ACE_NTOHL (0x63657300),  // name = supports_interfaces
   CORBA::tk_alias, // typecode kind for typedefs
-  164, // encapsulation length
+  228, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49645365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/RepositoryIdSeq:1.0
+    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x79496453), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/RepositoryIdSeq:1.0
     16, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x53657100),  // name = RepositoryIdSeq
     CORBA::tk_sequence, // typecode kind
-    88, // encapsulation length
+    156, // encapsulation length
       TAO_ENCAP_BYTE_ORDER, // byte order
       CORBA::tk_alias, // typecode kind for typedefs
-      72, // encapsulation length
+      140, // encapsulation length
         TAO_ENCAP_BYTE_ORDER, // byte order
-        35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
         13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-        CORBA::tk_string,
-        0U, // string length
+        CORBA::tk_alias, // typecode kind for typedefs
+        72, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_string, 
+          0U, // string length
+
 
       0U,
 
 
-  15, ACE_NTOHL (0x69735f74), ACE_NTOHL (0x72756e63), ACE_NTOHL (0x61746162), ACE_NTOHL (0x6c650000),  // name = is_truncatable
+  20, ACE_NTOHL (0x70726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x5f696e74), ACE_NTOHL (0x65726661), ACE_NTOHL (0x63657300),  // name = provides_interfaces
+  CORBA::tk_alias, // typecode kind for typedefs
+  144, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ProvidesDefSeq:1.0
+    15, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = ProvidesDefSeq
+    CORBA::tk_sequence, // typecode kind
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      56, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x726f7669), ACE_NTOHL (0x64657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ProvidesDef:1.0
+        12, ACE_NTOHL (0x50726f76), ACE_NTOHL (0x69646573), ACE_NTOHL (0x44656600),  // name = ProvidesDef
+
+      0U,
+
+
+  16, ACE_NTOHL (0x75736573), ACE_NTOHL (0x5f696e74), ACE_NTOHL (0x65726661), ACE_NTOHL (0x63657300),  // name = uses_interfaces
+  CORBA::tk_alias, // typecode kind for typedefs
+  128, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/UsesDefSeq:1.0
+    11, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = UsesDefSeq
+    CORBA::tk_sequence, // typecode kind
+    64, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      48, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f55), ACE_NTOHL (0x73657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/UsesDef:1.0
+        8, ACE_NTOHL (0x55736573), ACE_NTOHL (0x44656600),  // name = UsesDef
+
+      0U,
+
+
+  11, ACE_NTOHL (0x61747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65730000),  // name = attributes
+  CORBA::tk_alias, // typecode kind for typedefs
+  2424, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
+    19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    2344, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      2328, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
+        21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
+        8, // member count
+        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        132, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        3, ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        64, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        104, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
+          14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
+          2, // member count
+          12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
+          14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
+
+        15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        748, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          668, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            652, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              3, ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              64, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
+        15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        748, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          668, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            652, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              3, ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              64, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
+
+      0U,
+
+
+  13, ACE_NTOHL (0x656d6974), ACE_NTOHL (0x735f6576), ACE_NTOHL (0x656e7473), ACE_NTOHL (0x0),  // name = emits_events
+  CORBA::tk_alias, // typecode kind for typedefs
+  132, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/EmitsDefSeq:1.0
+    12, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x53657100),  // name = EmitsDefSeq
+    CORBA::tk_sequence, // typecode kind
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      52, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x6d697473), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/EmitsDef:1.0
+        9, ACE_NTOHL (0x456d6974), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = EmitsDef
+
+      0U,
+
+
+  17, ACE_NTOHL (0x7075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x735f6576), ACE_NTOHL (0x656e7473), ACE_NTOHL (0x0),  // name = publishes_events
+  CORBA::tk_alias, // typecode kind for typedefs
+  148, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65713a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/PublishesDefSeq:1.0
+    16, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x53657100),  // name = PublishesDefSeq
+    CORBA::tk_sequence, // typecode kind
+    76, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      60, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x75626c69), ACE_NTOHL (0x73686573), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/PublishesDef:1.0
+        13, ACE_NTOHL (0x5075626c), ACE_NTOHL (0x69736865), ACE_NTOHL (0x73446566), ACE_NTOHL (0x0),  // name = PublishesDef
+
+      0U,
+
+
+  16, ACE_NTOHL (0x636f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x5f657665), ACE_NTOHL (0x6e747300),  // name = consumes_events
+  CORBA::tk_alias, // typecode kind for typedefs
+  144, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65665365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/ConsumesDefSeq:1.0
+    15, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656653), ACE_NTOHL (0x65710000),  // name = ConsumesDefSeq
+    CORBA::tk_sequence, // typecode kind
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      56, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7375), ACE_NTOHL (0x6d657344), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/ConsumesDef:1.0
+        12, ACE_NTOHL (0x436f6e73), ACE_NTOHL (0x756d6573), ACE_NTOHL (0x44656600),  // name = ConsumesDef
+
+      0U,
+
+
+  9, ACE_NTOHL (0x69735f62), ACE_NTOHL (0x61736963), ACE_NTOHL (0x0),  // name = is_basic
   CORBA::tk_boolean,
 
-  11, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f76616c), ACE_NTOHL (0x75650000),  // name = base_value
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_ComponentDescription (CORBA::tk_struct, sizeof (_oc_IR_ComponentDescription), (char *) &_oc_IR_ComponentDescription, 0, sizeof (IR::ComponentDescription));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ComponentDescription, &_tc_TAO_tc_IR_ComponentDescription)
+TAO_NAMESPACE_END
+void IR::ComponentDescription::_tao_any_destructor (void *x)
+{
+  ComponentDescription *tmp = ACE_static_cast (ComponentDescription*,x);
+  delete tmp;
+}
+
+void IR::PrimaryKeyDef::_tao_any_destructor (void *x)
+{
+  PrimaryKeyDef *tmp = ACE_static_cast (PrimaryKeyDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::PrimaryKeyDef_ptr IR::PrimaryKeyDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return PrimaryKeyDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/PrimaryKeyDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (PrimaryKeyDef::_nil ());
+  if (is_a == 0)
+    return PrimaryKeyDef::_nil ();
+  return PrimaryKeyDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::PrimaryKeyDef_ptr IR::PrimaryKeyDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return PrimaryKeyDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  PrimaryKeyDef_ptr default_proxy = PrimaryKeyDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_PrimaryKeyDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_PrimaryKeyDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, PrimaryKeyDef (stub), PrimaryKeyDef::_nil ());
+  return TAO_IR_PrimaryKeyDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::PrimaryKeyDef_ptr 
+IR::PrimaryKeyDef::_duplicate (PrimaryKeyDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+CORBA::Boolean IR::PrimaryKeyDef::is_a (
+    const char * primary_key_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "is_a",
+      4,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "is_a",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << primary_key_id)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "is_a",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "is_a",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_retval;
+}
+
+IR::ValueDef_ptr IR::PrimaryKeyDef::primary_key (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ValueDef_ptr _tao_retval = IR::ValueDef::_nil ();
+  IR::ValueDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_primary_key",
+      16,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_primary_key",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_primary_key",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_primary_key",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Boolean IR::PrimaryKeyDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/PrimaryKeyDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::PrimaryKeyDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/PrimaryKeyDef:1.0";
+}
+
+IR::TAO_IR_PrimaryKeyDef_Default_Proxy_Factory::TAO_IR_PrimaryKeyDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_PrimaryKeyDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_PrimaryKeyDef_Default_Proxy_Factory::~TAO_IR_PrimaryKeyDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::PrimaryKeyDef_ptr
+IR::TAO_IR_PrimaryKeyDef_Default_Proxy_Factory::create_proxy (
+    ::IR::PrimaryKeyDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter::TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter::~TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_PrimaryKeyDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::PrimaryKeyDef_ptr
+IR::TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::PrimaryKeyDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_PrimaryKeyDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_PrimaryKeyDef_Smart_Proxy_Base::TAO_IR_PrimaryKeyDef_Smart_Proxy_Base (::IR::PrimaryKeyDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_PrimaryKeyDef_Smart_Proxy_Base::~TAO_IR_PrimaryKeyDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_PrimaryKeyDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::Boolean IR::TAO_IR_PrimaryKeyDef_Smart_Proxy_Base::is_a  (
+    const char * primary_key_id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_a (
+      primary_key_id,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ValueDef_ptr IR::TAO_IR_PrimaryKeyDef_Smart_Proxy_Base::primary_key  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->primary_key (
+      ACE_TRY_ENV
+    );
+
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_PrimaryKeyDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimaryKeyDef:1.0
+  14, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x6172794b), ACE_NTOHL (0x65794465), ACE_NTOHL (0x66000000),  // name = PrimaryKeyDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_PrimaryKeyDef (CORBA::tk_objref, sizeof (_oc_IR_PrimaryKeyDef), (char *) &_oc_IR_PrimaryKeyDef, 0, sizeof (IR::PrimaryKeyDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimaryKeyDef, &_tc_TAO_tc_IR_PrimaryKeyDef)
+TAO_NAMESPACE_END
+static const CORBA::Long _oc_IR_PrimaryKeyDescription[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  41, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimaryKeyDescription:1.0
+  22, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x6172794b), ACE_NTOHL (0x65794465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e000000),  // name = PrimaryKeyDescription
+  5, // member count
+  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
   CORBA::tk_alias, // typecode kind for typedefs
-  72, // encapsulation length
+  132, // encapsulation length
     TAO_ENCAP_BYTE_ORDER, // byte order
-    35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  3, ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
     13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
-    CORBA::tk_string,
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
     0U, // string length
 
+  12, ACE_NTOHL (0x7072696d), ACE_NTOHL (0x6172795f), ACE_NTOHL (0x6b657900),  // name = primary_key
+  CORBA::tk_objref, // typecode kind
+  52, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    28, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x616c7565), ACE_NTOHL (0x4465663a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ValueDef:1.0
+    9, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65446566), ACE_NTOHL (0x0),  // name = ValueDef
+
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueDescription (CORBA::tk_struct, sizeof (_oc_CORBA_ValueDescription), (char *) &_oc_CORBA_ValueDescription, 0, sizeof (CORBA_ValueDescription));
+static CORBA::TypeCode _tc_TAO_tc_IR_PrimaryKeyDescription (CORBA::tk_struct, sizeof (_oc_IR_PrimaryKeyDescription), (char *) &_oc_IR_PrimaryKeyDescription, 0, sizeof (IR::PrimaryKeyDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueDescription, &_tc_TAO_tc_CORBA_ValueDescription)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_PrimaryKeyDescription, &_tc_TAO_tc_IR_PrimaryKeyDescription)
 TAO_NAMESPACE_END
-CORBA_ValueBoxDef_ptr CORBA_ValueBoxDef::_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &ACE_TRY_ENV
+void IR::PrimaryKeyDescription::_tao_any_destructor (void *x)
+{
+  PrimaryKeyDescription *tmp = ACE_static_cast (PrimaryKeyDescription*,x);
+  delete tmp;
+}
+
+void IR::FactoryDef::_tao_any_destructor (void *x)
+{
+  FactoryDef *tmp = ACE_static_cast (FactoryDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::FactoryDef_ptr IR::FactoryDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ValueBoxDef::_nil ();
-  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/ValueBoxDef:1.0", ACE_TRY_ENV);
-  ACE_CHECK_RETURN (CORBA_ValueBoxDef::_nil ());
+    return FactoryDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/FactoryDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (FactoryDef::_nil ());
   if (is_a == 0)
-    return CORBA_ValueBoxDef::_nil ();
-  return CORBA_ValueBoxDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+    return FactoryDef::_nil ();
+  return FactoryDef::_unchecked_narrow (obj, ACE_TRY_ENV);
 }
 
-CORBA_ValueBoxDef_ptr CORBA_ValueBoxDef::_unchecked_narrow (
-    CORBA_Object_ptr obj,
-    CORBA_Environment &
+IR::FactoryDef_ptr IR::FactoryDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
   )
 {
   if (CORBA::is_nil (obj))
-    return CORBA_ValueBoxDef::_nil ();
+    return FactoryDef::_nil ();
   TAO_Stub* stub = obj->_stubobj ();
-  stub->_incr_refcnt ();
-  if (obj->_is_collocated () && _TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer != 0)
+  if (stub)
+    stub->_incr_refcnt ();
+  FactoryDef_ptr default_proxy = FactoryDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_FactoryDef_Stub_Factory_function_pointer != 0)
     {
-      CORBA_ValueBoxDef_ptr retv = _TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer (obj);
-      if (retv != 0)
-        return retv;
+      default_proxy = _TAO_collocation_IR_FactoryDef_Stub_Factory_function_pointer (obj);
     }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, FactoryDef (stub), FactoryDef::_nil ());
+  return TAO_IR_FactoryDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::FactoryDef_ptr 
+IR::FactoryDef::_duplicate (FactoryDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+CORBA::Boolean IR::FactoryDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/FactoryDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/OperationDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::FactoryDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/FactoryDef:1.0";
+}
+
+IR::TAO_IR_FactoryDef_Default_Proxy_Factory::TAO_IR_FactoryDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_FactoryDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_FactoryDef_Default_Proxy_Factory::~TAO_IR_FactoryDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::FactoryDef_ptr
+IR::TAO_IR_FactoryDef_Default_Proxy_Factory::create_proxy (
+    ::IR::FactoryDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_FactoryDef_Proxy_Factory_Adapter::TAO_IR_FactoryDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_FactoryDef_Proxy_Factory_Adapter::~TAO_IR_FactoryDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_FactoryDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_FactoryDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_FactoryDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::FactoryDef_ptr
+IR::TAO_IR_FactoryDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::FactoryDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_FactoryDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
 
-  CORBA_ValueBoxDef_ptr retval = CORBA_ValueBoxDef::_nil ();
+IR::TAO_IR_FactoryDef_Smart_Proxy_Base::TAO_IR_FactoryDef_Smart_Proxy_Base (::IR::FactoryDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_FactoryDef_Smart_Proxy_Base::~TAO_IR_FactoryDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_FactoryDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
 
-  ACE_NEW_RETURN (retval,
-                  CORBA_ValueBoxDef (stub),
-                  CORBA_ValueBoxDef::_nil ());
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_FactoryDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_FactoryDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-  return retval;
+static const CORBA::Long _oc_IR_FactoryDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/FactoryDef:1.0
+  11, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65660000),  // name = FactoryDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_FactoryDef (CORBA::tk_objref, sizeof (_oc_IR_FactoryDef), (char *) &_oc_IR_FactoryDef, 0, sizeof (IR::FactoryDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FactoryDef, &_tc_TAO_tc_IR_FactoryDef)
+TAO_NAMESPACE_END
+void IR::FinderDef::_tao_any_destructor (void *x)
+{
+  FinderDef *tmp = ACE_static_cast (FinderDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::FinderDef_ptr IR::FinderDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return FinderDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/FinderDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (FinderDef::_nil ());
+  if (is_a == 0)
+    return FinderDef::_nil ();
+  return FinderDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::FinderDef_ptr IR::FinderDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return FinderDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  FinderDef_ptr default_proxy = FinderDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_FinderDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_FinderDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, FinderDef (stub), FinderDef::_nil ());
+  return TAO_IR_FinderDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
 }
 
-CORBA_ValueBoxDef_ptr
-CORBA_ValueBoxDef::_duplicate (CORBA_ValueBoxDef_ptr obj)
+IR::FinderDef_ptr 
+IR::FinderDef::_duplicate (FinderDef_ptr obj)
 {
   if (!CORBA::is_nil (obj))
     obj->_incr_refcnt ();
   return obj;
 }
 
-CORBA_IDLType_ptr CORBA_ValueBoxDef::original_type_def (
-    CORBA_Environment &ACE_TRY_ENV
+CORBA::Boolean IR::FinderDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/FinderDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/OperationDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* IR::FinderDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/FinderDef:1.0";
+}
+
+IR::TAO_IR_FinderDef_Default_Proxy_Factory::TAO_IR_FinderDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_FinderDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_FinderDef_Default_Proxy_Factory::~TAO_IR_FinderDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::FinderDef_ptr
+IR::TAO_IR_FinderDef_Default_Proxy_Factory::create_proxy (
+    ::IR::FinderDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_FinderDef_Proxy_Factory_Adapter::TAO_IR_FinderDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_FinderDef_Proxy_Factory_Adapter::~TAO_IR_FinderDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_FinderDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_FinderDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_FinderDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::FinderDef_ptr
+IR::TAO_IR_FinderDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::FinderDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_FinderDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_FinderDef_Smart_Proxy_Base::TAO_IR_FinderDef_Smart_Proxy_Base (::IR::FinderDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_FinderDef_Smart_Proxy_Base::~TAO_IR_FinderDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_FinderDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_FinderDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_FinderDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_FinderDef[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FinderDef:1.0
+  10, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66000000),  // name = FinderDef
+};
+static CORBA::TypeCode _tc_TAO_tc_IR_FinderDef (CORBA::tk_objref, sizeof (_oc_IR_FinderDef), (char *) &_oc_IR_FinderDef, 0, sizeof (IR::FinderDef));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_FinderDef, &_tc_TAO_tc_IR_FinderDef)
+TAO_NAMESPACE_END
+void IR::HomeDef::_tao_any_destructor (void *x)
+{
+  HomeDef *tmp = ACE_static_cast (HomeDef*,x);
+  CORBA::release (tmp);
+}
+
+IR::HomeDef_ptr IR::HomeDef::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return HomeDef::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/IR/HomeDef:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (HomeDef::_nil ());
+  if (is_a == 0)
+    return HomeDef::_nil ();
+  return HomeDef::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+IR::HomeDef_ptr IR::HomeDef::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return HomeDef::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  HomeDef_ptr default_proxy = HomeDef::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_IR_HomeDef_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_IR_HomeDef_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, HomeDef (stub), HomeDef::_nil ());
+  return TAO_IR_HomeDef_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+IR::HomeDef_ptr 
+IR::HomeDef::_duplicate (HomeDef_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+IR::HomeDef_ptr IR::HomeDef::base_home (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+  IR::HomeDef_ptr _tao_retval = IR::HomeDef::_nil ();
+  IR::HomeDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-  CORBA_IDLType_ptr _tao_retval = CORBA_IDLType::_nil ();
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_base_home",
+      14,
+      istub->orb_core ()
+    );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_base_home",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_base_home",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_base_home",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
+IR::ComponentDef_ptr IR::HomeDef::managed_component (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::ComponentDef_ptr _tao_retval = IR::ComponentDef::_nil ();
+  IR::ComponentDef_var _tao_safe_retval (_tao_retval);
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW_RETURN (CORBA_INTERNAL (), _tao_retval);
-
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_get_""original_type_def",
+      "_get_managed_component",
       22,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_managed_component",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_managed_component",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_managed_component",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK_RETURN (_tao_retval);
+IR::PrimaryKeyDef_ptr IR::HomeDef::primary_key (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::PrimaryKeyDef_ptr _tao_retval = IR::PrimaryKeyDef::_nil ();
+  IR::PrimaryKeyDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK_RETURN (_tao_retval);
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_primary_key",
+      16,
+      istub->orb_core ()
+    );
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
-    {
-      ACE_THROW_RETURN (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
-    }
-    break;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-  }
-  TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
-  if (!(
-        (_tao_in >> _tao_retval)
-    ))
-    ACE_THROW_RETURN (CORBA_MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
-  return _tao_retval;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_primary_key",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_primary_key",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_primary_key",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-void CORBA_ValueBoxDef::original_type_def (
-    CORBA_IDLType_ptr original_type_def,
-    CORBA_Environment &ACE_TRY_ENV
+IR::FactoryDefSeq * IR::HomeDef::factories (
+    CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
+  
+  IR::FactoryDefSeq *_tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
+  
+  ACE_NEW_RETURN (_tao_retval, IR::FactoryDefSeq, _tao_retval);
+  IR::FactoryDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_factories",
+      14,
+      istub->orb_core ()
+    );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
 
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_factories",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_factories",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_factories",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+IR::FinderDefSeq * IR::HomeDef::finders (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::FinderDefSeq *_tao_retval = 0;
+  
+  
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
-    ACE_THROW (CORBA_INTERNAL ());
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  ACE_NEW_RETURN (_tao_retval, IR::FinderDefSeq, _tao_retval);
+  IR::FinderDefSeq_var _tao_safe_retval (_tao_retval);
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "_get_finders",
+      12,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_finders",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_finders",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_finders",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
+CORBA::Boolean IR::HomeDef::is_basic (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::Boolean _tao_retval = 0;
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), _tao_retval);
 
+  
   TAO_GIOP_Twoway_Invocation _tao_call (
       istub,
-      "_set_""original_type_def",
-      22,
+      "_get_is_basic",
+      13,
       istub->orb_core ()
     );
 
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN  (_tao_retval);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN  (_tao_retval);
+      }
 
-  for (;;)
-  {
-    _tao_call.start (ACE_TRY_ENV);
-    ACE_CHECK;
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    CORBA::Short flag = 131;
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_basic",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> CORBA::Any::to_boolean (_tao_retval))
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), _tao_retval);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "_get_is_basic",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN  (_tao_retval);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "_get_is_basic",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN  (_tao_retval);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_retval;
+}
 
-    _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag),
-                              ACE_TRY_ENV);
-    ACE_CHECK;
+IR::PrimaryKeyDef_ptr IR::HomeDef::create_primary_key (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ValueDef_ptr primary_key,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::PrimaryKeyDef_ptr _tao_retval = IR::PrimaryKeyDef::_nil ();
+  IR::PrimaryKeyDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
 
-    TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
-    if (!(
-          (_tao_out << original_type_def)
-      ))
-      ACE_THROW (CORBA_MARSHAL ());
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_primary_key",
+      18,
+      istub->orb_core ()
+    );
 
-    int _invoke_status =
-      _tao_call.invoke (0, 0, ACE_TRY_ENV);
-        ACE_CHECK;
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
-    if (_invoke_status == TAO_INVOKE_RESTART)
-      continue;
-    // if (_invoke_status == TAO_INVOKE_EXCEPTION)
-      // cannot happen
-    if (_invoke_status != TAO_INVOKE_OK)
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_primary_key",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << primary_key)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_primary_key",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
     {
-      ACE_THROW (CORBA_UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES));
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_primary_key",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
+IR::FactoryDef_ptr IR::HomeDef::create_factory (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::ParDescriptionSeq & params,
+    const IR::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::FactoryDef_ptr _tao_retval = IR::FactoryDef::_nil ();
+  IR::FactoryDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_factory",
+      14,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_factory",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << params) &&
+              (_tao_out << exceptions)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_factory",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
     }
-    break;
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_factory",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
 
-  }
+IR::FinderDef_ptr IR::HomeDef::create_finder (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::ParDescriptionSeq & params,
+    const IR::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  IR::FinderDef_ptr _tao_retval = IR::FinderDef::_nil ();
+  IR::FinderDef_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_finder",
+      13,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
 
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_finder",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << version) &&
+              (_tao_out << params) &&
+              (_tao_out << exceptions)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_finder",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_finder",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
 }
 
-CORBA::Boolean CORBA_ValueBoxDef::_is_a (const CORBA::Char *value, CORBA_Environment &ACE_TRY_ENV)
+CORBA::Boolean IR::HomeDef::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ValueBoxDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/HomeDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/InterfaceDef:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Container:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/Contained:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/IR/IDLType:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
   return 1; // success using local knowledge
@@ -13744,69 +36246,3729 @@ CORBA::Boolean CORBA_ValueBoxDef::_is_a (const CORBA::Char *value, CORBA_Environ
     return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
 }
 
-const char* CORBA_ValueBoxDef::_interface_repository_id (void) const
+const char* IR::HomeDef::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/IR/HomeDef:1.0";
+}
+
+IR::TAO_IR_HomeDef_Default_Proxy_Factory::TAO_IR_HomeDef_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_IR_HomeDef_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+IR::TAO_IR_HomeDef_Default_Proxy_Factory::~TAO_IR_HomeDef_Default_Proxy_Factory (void)
+{
+}
+
+IR::HomeDef_ptr
+IR::TAO_IR_HomeDef_Default_Proxy_Factory::create_proxy (
+    ::IR::HomeDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+IR::TAO_IR_HomeDef_Proxy_Factory_Adapter::TAO_IR_HomeDef_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+IR::TAO_IR_HomeDef_Proxy_Factory_Adapter::~TAO_IR_HomeDef_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+IR::TAO_IR_HomeDef_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_IR_HomeDef_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+IR::TAO_IR_HomeDef_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+IR::HomeDef_ptr
+IR::TAO_IR_HomeDef_Proxy_Factory_Adapter::create_proxy (
+    ::IR::HomeDef_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_IR_HomeDef_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+IR::TAO_IR_HomeDef_Smart_Proxy_Base::TAO_IR_HomeDef_Smart_Proxy_Base (::IR::HomeDef_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+IR::TAO_IR_HomeDef_Smart_Proxy_Base::~TAO_IR_HomeDef_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+IR::TAO_IR_HomeDef_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+IR::HomeDef_ptr IR::TAO_IR_HomeDef_Smart_Proxy_Base::base_home  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->base_home (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::ComponentDef_ptr IR::TAO_IR_HomeDef_Smart_Proxy_Base::managed_component  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->managed_component (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::PrimaryKeyDef_ptr IR::TAO_IR_HomeDef_Smart_Proxy_Base::primary_key  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->primary_key (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::FactoryDefSeq * IR::TAO_IR_HomeDef_Smart_Proxy_Base::factories  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->factories (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::FinderDefSeq * IR::TAO_IR_HomeDef_Smart_Proxy_Base::finders  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->finders (
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::Boolean IR::TAO_IR_HomeDef_Smart_Proxy_Base::is_basic  (
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->is_basic (
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::PrimaryKeyDef_ptr IR::TAO_IR_HomeDef_Smart_Proxy_Base::create_primary_key  (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::ValueDef_ptr primary_key,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_primary_key (
+      id,
+      name,
+      version,
+      primary_key,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::FactoryDef_ptr IR::TAO_IR_HomeDef_Smart_Proxy_Base::create_factory  (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::ParDescriptionSeq & params,
+    const IR::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_factory (
+      id,
+      name,
+      version,
+      params,
+      exceptions,
+      ACE_TRY_ENV
+    );
+
+}
+
+IR::FinderDef_ptr IR::TAO_IR_HomeDef_Smart_Proxy_Base::create_finder  (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::ParDescriptionSeq & params,
+    const IR::ExceptionDefSeq & exceptions,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
 {
-  return "IDL:omg.org/CORBA/ValueBoxDef:1.0";
+  return this->base_proxy_->create_finder (
+      id,
+      name,
+      version,
+      params,
+      exceptions,
+      ACE_TRY_ENV
+    );
+
 }
 
-static const CORBA::Long _oc_CORBA_ValueBoxDef[] =
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<IR::TAO_IR_HomeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<IR::TAO_IR_HomeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_IR_HomeDef[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  34, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c756542), ACE_NTOHL (0x6f784465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/ValueBoxDef:1.0
-  12, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x65426f78), ACE_NTOHL (0x44656600),  // name = ValueBoxDef
+  27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f48), ACE_NTOHL (0x6f6d6544), ACE_NTOHL (0x65663a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/HomeDef:1.0
+  8, ACE_NTOHL (0x486f6d65), ACE_NTOHL (0x44656600),  // name = HomeDef
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueBoxDef (CORBA::tk_objref, sizeof (_oc_CORBA_ValueBoxDef), (char *) &_oc_CORBA_ValueBoxDef, 0, sizeof (CORBA_ValueBoxDef));
+static CORBA::TypeCode _tc_TAO_tc_IR_HomeDef (CORBA::tk_objref, sizeof (_oc_IR_HomeDef), (char *) &_oc_IR_HomeDef, 0, sizeof (IR::HomeDef));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueBoxDef, &_tc_TAO_tc_CORBA_ValueBoxDef)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HomeDef, &_tc_TAO_tc_IR_HomeDef)
 TAO_NAMESPACE_END
-static const CORBA::Long _oc_CORBA_ValueModifier[] =
+static const CORBA::Long _oc_IR_HomeDescription[] =
 {
   TAO_ENCAP_BYTE_ORDER, // byte order
-  36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5661), ACE_NTOHL (0x6c75654d), ACE_NTOHL (0x6f646966), ACE_NTOHL (0x6965723a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/CORBA/ValueModifier:1.0
-  14, ACE_NTOHL (0x56616c75), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ValueModifier
-  CORBA::tk_short,
+  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f48), ACE_NTOHL (0x6f6d6544), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e3a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/HomeDescription:1.0
+  16, ACE_NTOHL (0x486f6d65), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e00),  // name = HomeDescription
+  12, // member count
+  5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+  CORBA::tk_alias, // typecode kind for typedefs
+  132, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+    11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+    CORBA::tk_alias, // typecode kind for typedefs
+    68, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+      11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  3, ACE_NTOHL (0x69640000),  // name = id
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+  CORBA::tk_alias, // typecode kind for typedefs
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+    12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+    CORBA::tk_string, 
+    0U, // string length
+
+  10, ACE_NTOHL (0x62617365), ACE_NTOHL (0x5f686f6d), ACE_NTOHL (0x65000000),  // name = base_home
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  18, ACE_NTOHL (0x6d616e61), ACE_NTOHL (0x6765645f), ACE_NTOHL (0x636f6d70), ACE_NTOHL (0x6f6e656e), ACE_NTOHL (0x74000000),  // name = managed_component
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+    13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+    CORBA::tk_alias, // typecode kind for typedefs
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+      13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+      CORBA::tk_string, 
+      0U, // string length
+
+
+  16, ACE_NTOHL (0x7072696d), ACE_NTOHL (0x6172795f), ACE_NTOHL (0x6b65795f), ACE_NTOHL (0x64656600),  // name = primary_key_def
+  CORBA::tk_objref, // typecode kind
+  64, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x72696d61), ACE_NTOHL (0x72794b65), ACE_NTOHL (0x79446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/PrimaryKeyDef:1.0
+    14, ACE_NTOHL (0x5072696d), ACE_NTOHL (0x6172794b), ACE_NTOHL (0x65794465), ACE_NTOHL (0x66000000),  // name = PrimaryKeyDef
+
+  10, ACE_NTOHL (0x66616374), ACE_NTOHL (0x6f726965), ACE_NTOHL (0x73000000),  // name = factories
+  CORBA::tk_alias, // typecode kind for typedefs
+  144, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x66536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FactoryDefSeq:1.0
+    14, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65665365), ACE_NTOHL (0x71000000),  // name = FactoryDefSeq
+    CORBA::tk_sequence, // typecode kind
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      56, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x6163746f), ACE_NTOHL (0x72794465), ACE_NTOHL (0x663a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/FactoryDef:1.0
+        11, ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727944), ACE_NTOHL (0x65660000),  // name = FactoryDef
+
+      0U,
+
+
+  8, ACE_NTOHL (0x66696e64), ACE_NTOHL (0x65727300),  // name = finders
+  CORBA::tk_alias, // typecode kind for typedefs
+  140, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/FinderDefSeq:1.0
+    13, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66536571), ACE_NTOHL (0x0),  // name = FinderDefSeq
+    CORBA::tk_sequence, // typecode kind
+    72, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_objref, // typecode kind
+      56, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        29, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f46), ACE_NTOHL (0x696e6465), ACE_NTOHL (0x72446566), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/FinderDef:1.0
+        10, ACE_NTOHL (0x46696e64), ACE_NTOHL (0x65724465), ACE_NTOHL (0x66000000),  // name = FinderDef
+
+      0U,
+
+
+  11, ACE_NTOHL (0x6f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e730000),  // name = operations
+  CORBA::tk_alias, // typecode kind for typedefs
+  2532, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    36, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OpDescriptionSeq:1.0
+    17, ACE_NTOHL (0x4f704465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x0),  // name = OpDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    2456, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      2440, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/OperationDescription:1.0
+        21, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = OperationDescription
+        9, // member count
+        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        132, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        3, ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        64, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        7, ACE_NTOHL (0x72657375), ACE_NTOHL (0x6c740000),  // name = result
+        CORBA::tk_TypeCode,
+
+        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        100, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f4f), ACE_NTOHL (0x70657261), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/OperationMode:1.0
+          14, ACE_NTOHL (0x4f706572), ACE_NTOHL (0x6174696f), ACE_NTOHL (0x6e4d6f64), ACE_NTOHL (0x65000000),  // name = OperationMode
+          2, // member count
+          10, ACE_NTOHL (0x4f505f4e), ACE_NTOHL (0x4f524d41), ACE_NTOHL (0x4c000000),  // name = OP_NORMAL
+          10, ACE_NTOHL (0x4f505f4f), ACE_NTOHL (0x4e455741), ACE_NTOHL (0x59000000),  // name = OP_ONEWAY
+
+        9, ACE_NTOHL (0x636f6e74), ACE_NTOHL (0x65787473), ACE_NTOHL (0x0),  // name = contexts
+        CORBA::tk_alias, // typecode kind for typedefs
+        296, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x5365713a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ContextIdSeq:1.0
+          13, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64536571), ACE_NTOHL (0x0),  // name = ContextIdSeq
+          CORBA::tk_sequence, // typecode kind
+          228, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_alias, // typecode kind for typedefs
+            212, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f43), ACE_NTOHL (0x6f6e7465), ACE_NTOHL (0x78744964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ContextIdentifier:1.0
+              18, ACE_NTOHL (0x436f6e74), ACE_NTOHL (0x65787449), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x72000000),  // name = ContextIdentifier
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+
+            0U,
+
+
+        11, ACE_NTOHL (0x70617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72730000),  // name = parameters
+        CORBA::tk_alias, // typecode kind for typedefs
+        552, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x61724465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParDescriptionSeq:1.0
+          18, ACE_NTOHL (0x50617244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ParDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          472, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            456, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ParameterDescription:1.0
+              21, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x72446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ParameterDescription
+              4, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+              9, ACE_NTOHL (0x74797065), ACE_NTOHL (0x5f646566), ACE_NTOHL (0x0),  // name = type_def
+              CORBA::tk_objref, // typecode kind
+              48, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                27, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x444c5479), ACE_NTOHL (0x70653a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/IDLType:1.0
+                8, ACE_NTOHL (0x49444c54), ACE_NTOHL (0x79706500),  // name = IDLType
+
+              5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
+              CORBA::tk_enum, // typecode kind
+              116, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f50), ACE_NTOHL (0x6172616d), ACE_NTOHL (0x65746572), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ParameterMode:1.0
+                14, ACE_NTOHL (0x50617261), ACE_NTOHL (0x6d657465), ACE_NTOHL (0x724d6f64), ACE_NTOHL (0x65000000),  // name = ParameterMode
+                3, // member count
+                9, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x0),  // name = PARAM_IN
+                10, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f4f55), ACE_NTOHL (0x54000000),  // name = PARAM_OUT
+                12, ACE_NTOHL (0x50415241), ACE_NTOHL (0x4d5f494e), ACE_NTOHL (0x4f555400),  // name = PARAM_INOUT
+
+
+            0U,
+
+
+        11, ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        748, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          668, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            652, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              3, ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              64, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
+
+      0U,
+
+
+  11, ACE_NTOHL (0x61747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65730000),  // name = attributes
+  CORBA::tk_alias, // typecode kind for typedefs
+  2424, // encapsulation length
+    TAO_ENCAP_BYTE_ORDER, // byte order
+    38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747244), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x713a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/AttrDescriptionSeq:1.0
+    19, ACE_NTOHL (0x41747472), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x65710000),  // name = AttrDescriptionSeq
+    CORBA::tk_sequence, // typecode kind
+    2344, // encapsulation length
+      TAO_ENCAP_BYTE_ORDER, // byte order
+      CORBA::tk_struct, // typecode kind
+      2328, // encapsulation length
+        TAO_ENCAP_BYTE_ORDER, // byte order
+        40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/AttributeDescription:1.0
+        21, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x65446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = AttributeDescription
+        8, // member count
+        5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+        CORBA::tk_alias, // typecode kind for typedefs
+        132, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+          11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+          CORBA::tk_alias, // typecode kind for typedefs
+          68, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+            11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        3, ACE_NTOHL (0x69640000),  // name = id
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+        CORBA::tk_alias, // typecode kind for typedefs
+        140, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+          13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+          CORBA::tk_alias, // typecode kind for typedefs
+          72, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+            13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+            CORBA::tk_string, 
+            0U, // string length
+
+
+        8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+        CORBA::tk_alias, // typecode kind for typedefs
+        64, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+          12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+          CORBA::tk_string, 
+          0U, // string length
+
+        5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+        CORBA::tk_TypeCode,
+
+        5, ACE_NTOHL (0x6d6f6465), ACE_NTOHL (0x0),  // name = mode
+        CORBA::tk_enum, // typecode kind
+        104, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f41), ACE_NTOHL (0x74747269), ACE_NTOHL (0x62757465), ACE_NTOHL (0x4d6f6465), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/AttributeMode:1.0
+          14, ACE_NTOHL (0x41747472), ACE_NTOHL (0x69627574), ACE_NTOHL (0x654d6f64), ACE_NTOHL (0x65000000),  // name = AttributeMode
+          2, // member count
+          12, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f4e4f52), ACE_NTOHL (0x4d414c00),  // name = ATTR_NORMAL
+          14, ACE_NTOHL (0x41545452), ACE_NTOHL (0x5f524541), ACE_NTOHL (0x444f4e4c), ACE_NTOHL (0x59000000),  // name = ATTR_READONLY
+
+        15, ACE_NTOHL (0x6765745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = get_exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        748, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          668, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            652, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              3, ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              64, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
+        15, ACE_NTOHL (0x7075745f), ACE_NTOHL (0x65786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e730000),  // name = put_exceptions
+        CORBA::tk_alias, // typecode kind for typedefs
+        748, // encapsulation length
+          TAO_ENCAP_BYTE_ORDER, // byte order
+          37, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78634465), ACE_NTOHL (0x73637269), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e536571), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/IR/ExcDescriptionSeq:1.0
+          18, ACE_NTOHL (0x45786344), ACE_NTOHL (0x65736372), ACE_NTOHL (0x69707469), ACE_NTOHL (0x6f6e5365), ACE_NTOHL (0x71000000),  // name = ExcDescriptionSeq
+          CORBA::tk_sequence, // typecode kind
+          668, // encapsulation length
+            TAO_ENCAP_BYTE_ORDER, // byte order
+            CORBA::tk_struct, // typecode kind
+            652, // encapsulation length
+              TAO_ENCAP_BYTE_ORDER, // byte order
+              40, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f45), ACE_NTOHL (0x78636570), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x44657363), ACE_NTOHL (0x72697074), ACE_NTOHL (0x696f6e3a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/ExceptionDescription:1.0
+              21, ACE_NTOHL (0x45786365), ACE_NTOHL (0x7074696f), ACE_NTOHL (0x6e446573), ACE_NTOHL (0x63726970), ACE_NTOHL (0x74696f6e), ACE_NTOHL (0x0),  // name = ExceptionDescription
+              5, // member count
+              5, ACE_NTOHL (0x6e616d65), ACE_NTOHL (0x0),  // name = name
+              CORBA::tk_alias, // typecode kind for typedefs
+              132, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                30, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f49), ACE_NTOHL (0x64656e74), ACE_NTOHL (0x69666965), ACE_NTOHL (0x723a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/IR/Identifier:1.0
+                11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                CORBA::tk_alias, // typecode kind for typedefs
+                68, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  33, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f4964), ACE_NTOHL (0x656e7469), ACE_NTOHL (0x66696572), ACE_NTOHL (0x3a312e30), ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/CORBA/Identifier:1.0
+                  11, ACE_NTOHL (0x4964656e), ACE_NTOHL (0x74696669), ACE_NTOHL (0x65720000),  // name = Identifier
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              3, ACE_NTOHL (0x69640000),  // name = id
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              11, ACE_NTOHL (0x64656669), ACE_NTOHL (0x6e65645f), ACE_NTOHL (0x696e0000),  // name = defined_in
+              CORBA::tk_alias, // typecode kind for typedefs
+              140, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                32, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f52), ACE_NTOHL (0x65706f73), ACE_NTOHL (0x69746f72), ACE_NTOHL (0x7949643a), ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/IR/RepositoryId:1.0
+                13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                CORBA::tk_alias, // typecode kind for typedefs
+                72, // encapsulation length
+                  TAO_ENCAP_BYTE_ORDER, // byte order
+                  35, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5265), ACE_NTOHL (0x706f7369), ACE_NTOHL (0x746f7279), ACE_NTOHL (0x49643a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/CORBA/RepositoryId:1.0
+                  13, ACE_NTOHL (0x5265706f), ACE_NTOHL (0x7369746f), ACE_NTOHL (0x72794964), ACE_NTOHL (0x0),  // name = RepositoryId
+                  CORBA::tk_string, 
+                  0U, // string length
+
+
+              8, ACE_NTOHL (0x76657273), ACE_NTOHL (0x696f6e00),  // name = version
+              CORBA::tk_alias, // typecode kind for typedefs
+              64, // encapsulation length
+                TAO_ENCAP_BYTE_ORDER, // byte order
+                31, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x49522f56), ACE_NTOHL (0x65727369), ACE_NTOHL (0x6f6e5370), ACE_NTOHL (0x65633a31), ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/IR/VersionSpec:1.0
+                12, ACE_NTOHL (0x56657273), ACE_NTOHL (0x696f6e53), ACE_NTOHL (0x70656300),  // name = VersionSpec
+                CORBA::tk_string, 
+                0U, // string length
+
+              5, ACE_NTOHL (0x74797065), ACE_NTOHL (0x0),  // name = type
+              CORBA::tk_TypeCode,
+
+
+            0U,
+
+
+
+      0U,
+
+
+  9, ACE_NTOHL (0x69735f62), ACE_NTOHL (0x61736963), ACE_NTOHL (0x0),  // name = is_basic
+  CORBA::tk_boolean,
 
 };
-static CORBA::TypeCode _tc_TAO_tc_CORBA_ValueModifier (CORBA::tk_alias, sizeof (_oc_CORBA_ValueModifier), (char *) &_oc_CORBA_ValueModifier, 0, sizeof (CORBA::ValueModifier));
+static CORBA::TypeCode _tc_TAO_tc_IR_HomeDescription (CORBA::tk_struct, sizeof (_oc_IR_HomeDescription), (char *) &_oc_IR_HomeDescription, 0, sizeof (IR::HomeDescription));
 TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_ValueModifier, &_tc_TAO_tc_CORBA_ValueModifier)
-TAO_NAMESPACE_END
-TAO_NAMESPACE_TYPE (const CORBA::Short)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (const CORBA::Short, VM_NONE, 0)
-TAO_NAMESPACE_END
-TAO_NAMESPACE_TYPE (const CORBA::Short)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (const CORBA::Short, VM_CUSTOM, 1)
-TAO_NAMESPACE_END
-TAO_NAMESPACE_TYPE (const CORBA::Short)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (const CORBA::Short, VM_ABSTRACT, 2)
-TAO_NAMESPACE_END
-TAO_NAMESPACE_TYPE (const CORBA::Short)
-TAO_NAMESPACE_BEGIN (CORBA)
-TAO_NAMESPACE_DEFINE (const CORBA::Short, VM_TRUNCATABLE, 3)
+TAO_NAMESPACE_BEGIN (IR)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_HomeDescription, &_tc_TAO_tc_IR_HomeDescription)
 TAO_NAMESPACE_END
+void IR::HomeDescription::_tao_any_destructor (void *x)
+{
+  HomeDescription *tmp = ACE_static_cast (HomeDescription*,x);
+  delete tmp;
+}
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::DefinitionKind _tao_elem)
+void CORBA::TypeCodeFactory::_tao_any_destructor (void *x)
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_DefinitionKind,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TypeCodeFactory *tmp = ACE_static_cast (TypeCodeFactory*,x);
+  CORBA::release (tmp);
+}
+
+CORBA::TypeCodeFactory_ptr CORBA::TypeCodeFactory::_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+{
+  if (CORBA::is_nil (obj))
+    return TypeCodeFactory::_nil ();
+  CORBA::Boolean is_a = obj->_is_a ("IDL:omg.org/CORBA/TypeCodeFactory:1.0", ACE_TRY_ENV);
+  ACE_CHECK_RETURN (TypeCodeFactory::_nil ());
+  if (is_a == 0)
+    return TypeCodeFactory::_nil ();
+  return TypeCodeFactory::_unchecked_narrow (obj, ACE_TRY_ENV);
+}
+
+CORBA::TypeCodeFactory_ptr CORBA::TypeCodeFactory::_unchecked_narrow (
+    CORBA::Object_ptr obj,
+    CORBA::Environment &
+  )
+{
+  if (CORBA::is_nil (obj))
+    return TypeCodeFactory::_nil ();
+  TAO_Stub* stub = obj->_stubobj ();
+  if (stub)
+    stub->_incr_refcnt ();
+  TypeCodeFactory_ptr default_proxy = TypeCodeFactory::_nil ();
+  if (obj->_is_collocated () && _TAO_collocation_CORBA_TypeCodeFactory_Stub_Factory_function_pointer != 0)
+    {
+      default_proxy = _TAO_collocation_CORBA_TypeCodeFactory_Stub_Factory_function_pointer (obj);
+    }
+  if (CORBA::is_nil (default_proxy))
+    ACE_NEW_RETURN (default_proxy, TypeCodeFactory (stub), TypeCodeFactory::_nil ());
+  return TAO_CORBA_TypeCodeFactory_PROXY_FACTORY_ADAPTER::instance ()->create_proxy (default_proxy);
+}
+
+CORBA::TypeCodeFactory_ptr 
+CORBA::TypeCodeFactory::_duplicate (TypeCodeFactory_ptr obj)
+{
+  if (!CORBA::is_nil (obj))
+    obj->_incr_refcnt ();
+  return obj;
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_struct_tc (
+    const char * id,
+    const char * name,
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_struct_tc",
+      16,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_struct_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_struct_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_struct_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_union_tc (
+    const char * id,
+    const char * name,
+    CORBA::TypeCode_ptr discriminator_type,
+    const IR::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_union_tc",
+      15,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_union_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << discriminator_type) &&
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_union_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_union_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_enum_tc (
+    const char * id,
+    const char * name,
+    const IR::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_enum_tc",
+      14,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_enum_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_enum_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_enum_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_alias_tc (
+    const char * id,
+    const char * name,
+    CORBA::TypeCode_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_alias_tc",
+      15,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_alias_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << original_type)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_alias_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_alias_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_exception_tc (
+    const char * id,
+    const char * name,
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_exception_tc",
+      19,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_exception_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_exception_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_exception_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_interface_tc (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_interface_tc",
+      19,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_interface_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_interface_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_interface_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_string_tc (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_string_tc",
+      16,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_string_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << bound)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_string_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_string_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_wstring_tc (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_wstring_tc",
+      17,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_wstring_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << bound)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_wstring_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_wstring_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_fixed_tc (
+    CORBA::UShort digits,
+    CORBA::UShort scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_fixed_tc",
+      15,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_fixed_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << digits) &&
+              (_tao_out << scale)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_fixed_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_fixed_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_sequence_tc (
+    CORBA::ULong bound,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_sequence_tc",
+      18,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_sequence_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << bound) &&
+              (_tao_out << element_type)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_sequence_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_sequence_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_array_tc (
+    CORBA::ULong length,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_array_tc",
+      15,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_array_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << length) &&
+              (_tao_out << element_type)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_array_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_array_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_value_tc (
+    const char * id,
+    const char * name,
+    CORBA::ValueModifier type_modifier,
+    CORBA::TypeCode_ptr concrete_base,
+    const IR::ValueMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_value_tc",
+      15,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << type_modifier) &&
+              (_tao_out << concrete_base) &&
+              (_tao_out << members)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_value_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_value_box_tc (
+    const char * id,
+    const char * name,
+    CORBA::TypeCode_ptr boxed_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_value_box_tc",
+      19,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value_box_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name) &&
+              (_tao_out << boxed_type)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_value_box_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_value_box_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_native_tc (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_native_tc",
+      16,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_native_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_native_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_native_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_recursive_tc (
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_recursive_tc",
+      19,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_recursive_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_recursive_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_recursive_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_abstract_interface_tc (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_abstract_interface_tc",
+      28,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_abstract_interface_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_abstract_interface_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_abstract_interface_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_component_tc (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_component_tc",
+      19,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_component_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_component_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_component_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::TypeCode_ptr CORBA::TypeCodeFactory::create_home_tc (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  
+  CORBA::TypeCode_ptr _tao_retval = CORBA::TypeCode::_nil ();
+  CORBA::TypeCode_var _tao_safe_retval (_tao_retval);
+  
+  
+  TAO_Stub *istub = this->_stubobj ();
+  if (istub == 0)
+    ACE_THROW_RETURN (CORBA::INTERNAL (), 0);
+
+  
+  TAO_GIOP_Twoway_Invocation _tao_call (
+      istub,
+      "create_home_tc",
+      14,
+      istub->orb_core ()
+    );
+
+#if defined (TAO_HAS_INTERCEPTORS)
+    TAO_ClientRequestInterceptor_Adapter
+      _tao_vfr (istub->orb_core ()->orb ()->_get_client_interceptor (ACE_TRY_ENV));
+    ACE_CHECK_RETURN (0);
+    PortableInterceptor::Cookies _tao_cookies;
+    CORBA::NVList_var _tao_interceptor_args;
+    if (_tao_vfr.valid ())
+      {
+        istub->orb_core ()->orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
+        ACE_CHECK_RETURN (0);
+      }
+
+    ACE_TRY
+      {
+#endif /* TAO_HAS_INTERCEPTORS */
+
+      for (;;)
+      {
+        _tao_call.start (ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.preinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_home_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        CORBA::Short flag = 131;
+        // Tremporary hack until GIOP 1.2 is implemented.
+        
+        _tao_call.prepare_header (ACE_static_cast (CORBA::Octet, flag), ACE_TRY_ENV);
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        TAO_OutputCDR &_tao_out = _tao_call.out_stream ();
+        if (!(
+              (_tao_out << id) &&
+              (_tao_out << name)
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (), 0);
+
+        int _invoke_status =
+          _tao_call.invoke (0, 0, ACE_TRY_ENV);
+                TAO_INTERCEPTOR_CHECK_RETURN (0);
+
+        if (_invoke_status == TAO_INVOKE_RESTART)
+          continue;
+        if (_invoke_status != TAO_INVOKE_OK)
+        {
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::UNKNOWN (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        }
+        TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
+        if (!(
+              (_tao_in >> _tao_safe_retval.inout ())
+          ))
+          TAO_INTERCEPTOR_THROW_RETURN (CORBA::MARSHAL (TAO_DEFAULT_MINOR_CODE, CORBA::COMPLETED_YES), 0);
+
+        TAO_INTERCEPTOR (
+            _tao_vfr.postinvoke (
+                _tao_call.request_id (),
+                1,
+                this,
+                "create_home_tc",
+                _tao_call.service_info (),
+                _tao_interceptor_args.inout (),
+                _tao_cookies,
+                ACE_TRY_ENV
+              )
+          );
+        TAO_INTERCEPTOR_CHECK_RETURN (0);
+        break;
+        
+      }
+#if defined (TAO_HAS_INTERCEPTORS)
+      
+    }
+  ACE_CATCHANY
+    {
+      _tao_vfr.exception_occurred (
+          _tao_call.request_id (),
+          1,
+          this,
+          "create_home_tc",
+          _tao_cookies,
+          ACE_TRY_ENV
+        );
+      ACE_RETHROW;
+    }
+  ACE_ENDTRY;
+  ACE_CHECK_RETURN (0);
+#endif /* TAO_HAS_INTERCEPTORS */
+  return _tao_safe_retval._retn ();
+}
+
+CORBA::Boolean CORBA::TypeCodeFactory::_is_a (const CORBA::Char *value, CORBA::Environment &ACE_TRY_ENV)
+{
+  if (
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypeCodeFactory:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Object:1.0")))
+  return 1; // success using local knowledge
+  else
+    return this->CORBA_Object::_is_a (value, ACE_TRY_ENV);
+}
+
+const char* CORBA::TypeCodeFactory::_interface_repository_id (void) const
+{
+  return "IDL:omg.org/CORBA/TypeCodeFactory:1.0";
+}
+
+CORBA::TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory::TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory (int register_proxy_factory)
+{
+  if (register_proxy_factory)
+    {
+      TAO_CORBA_TypeCodeFactory_PROXY_FACTORY_ADAPTER::instance ()->register_proxy_factory (this);
+    }
+}
+
+CORBA::TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory::~TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory (void)
+{
+}
+
+CORBA::TypeCodeFactory_ptr
+CORBA::TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory::create_proxy (
+    ::CORBA::TypeCodeFactory_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  return proxy;
+}
+
+CORBA::TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter::TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter (void)
+   : proxy_factory_ (0),
+     delete_proxy_factory_ (0)
+{
+}
+
+CORBA::TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter::~TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter (void)
+{
+  // Making sure the factory which the adapter has is destroyed with it.
+  if (this->proxy_factory_ != 0)
+    delete this->proxy_factory_;
+}
+
+int
+CORBA::TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter::register_proxy_factory (
+  TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory *df,
+     CORBA::Environment &ACE_TRY_ENV
+      )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Remove any existing <proxy_factory_> and replace with the new one.
+  this->unregister_proxy_factory (ACE_TRY_ENV);
+  this->proxy_factory_ = df;
+  this->delete_proxy_factory_ = 0;
+return 0;
+}
+
+int
+CORBA::TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter::unregister_proxy_factory (
+  CORBA::Environment &
+    )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  if (this->delete_proxy_factory_ == 0 && this->proxy_factory_ != 0)
+    {
+      // Its necessary to set <delete_proxy_factory_> to 1 to make sure that it
+      // doesnt get into an infinite loop in <unregister_proxy_factory> as it is 
+      // invoked in the destructor of the class too.
+      this->delete_proxy_factory_ = 1;
+      delete this->proxy_factory_;
+      this->proxy_factory_ = 0;
+    }
+return 0;
+}
+
+CORBA::TypeCodeFactory_ptr
+CORBA::TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter::create_proxy (
+    ::CORBA::TypeCodeFactory_ptr proxy,
+    CORBA::Environment &
+  )
+{
+  ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon,
+    this->lock_, 0));
+  // Verify that an <proxy_factory_> is available else make one.
+  if (this->proxy_factory_ == 0)
+    ACE_NEW_RETURN (this->proxy_factory_,
+        TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory (1), 
+         0);
+      
+    
+  return this->proxy_factory_->create_proxy (proxy);
+}
+
+CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base (::CORBA::TypeCodeFactory_ptr proxy)
+: base_proxy_ (proxy)
+{
+}
+
+CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::~TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base (void)
+{
+}
+
+TAO_Stub *
+CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::_stubobj (void) const
+{
+  return this->base_proxy_->_stubobj ();
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_struct_tc  (
+    const char * id,
+    const char * name,
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_struct_tc (
+      id,
+      name,
+      members,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_union_tc  (
+    const char * id,
+    const char * name,
+    CORBA::TypeCode_ptr discriminator_type,
+    const IR::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_union_tc (
+      id,
+      name,
+      discriminator_type,
+      members,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_enum_tc  (
+    const char * id,
+    const char * name,
+    const IR::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_enum_tc (
+      id,
+      name,
+      members,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_alias_tc  (
+    const char * id,
+    const char * name,
+    CORBA::TypeCode_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_alias_tc (
+      id,
+      name,
+      original_type,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_exception_tc  (
+    const char * id,
+    const char * name,
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_exception_tc (
+      id,
+      name,
+      members,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_interface_tc  (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_interface_tc (
+      id,
+      name,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_string_tc  (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_string_tc (
+      bound,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_wstring_tc  (
+    CORBA::ULong bound,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_wstring_tc (
+      bound,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_fixed_tc  (
+    CORBA::UShort digits,
+    CORBA::UShort scale,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_fixed_tc (
+      digits,
+      scale,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_sequence_tc  (
+    CORBA::ULong bound,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_sequence_tc (
+      bound,
+      element_type,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_array_tc  (
+    CORBA::ULong length,
+    CORBA::TypeCode_ptr element_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_array_tc (
+      length,
+      element_type,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_value_tc  (
+    const char * id,
+    const char * name,
+    CORBA::ValueModifier type_modifier,
+    CORBA::TypeCode_ptr concrete_base,
+    const IR::ValueMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_value_tc (
+      id,
+      name,
+      type_modifier,
+      concrete_base,
+      members,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_value_box_tc  (
+    const char * id,
+    const char * name,
+    CORBA::TypeCode_ptr boxed_type,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_value_box_tc (
+      id,
+      name,
+      boxed_type,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_native_tc  (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_native_tc (
+      id,
+      name,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_recursive_tc  (
+    const char * id,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_recursive_tc (
+      id,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_abstract_interface_tc  (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_abstract_interface_tc (
+      id,
+      name,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_component_tc  (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_component_tc (
+      id,
+      name,
+      ACE_TRY_ENV
+    );
+
+}
+
+CORBA::TypeCode_ptr CORBA::TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base::create_home_tc  (
+    const char * id,
+    const char * name,
+    CORBA::Environment &ACE_TRY_ENV
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ))
+{
+  return this->base_proxy_->create_home_tc (
+      id,
+      name,
+      ACE_TRY_ENV
+    );
+
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DefinitionKind &_tao_elem)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) || \
+  defined (ACE_HAS_GNU_REPO)
+template class ACE_Singleton<CORBA::TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX >;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#pragma instantiate ACE_Singleton<CORBA::TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+static const CORBA::Long _oc_CORBA_TypeCodeFactory[] =
+{
+  TAO_ENCAP_BYTE_ORDER, // byte order
+  38, ACE_NTOHL (0x49444c3a), ACE_NTOHL (0x6f6d672e), ACE_NTOHL (0x6f72672f), ACE_NTOHL (0x434f5242), ACE_NTOHL (0x412f5479), ACE_NTOHL (0x7065436f), ACE_NTOHL (0x64654661), ACE_NTOHL (0x63746f72), ACE_NTOHL (0x793a312e), ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/CORBA/TypeCodeFactory:1.0
+  16, ACE_NTOHL (0x54797065), ACE_NTOHL (0x436f6465), ACE_NTOHL (0x46616374), ACE_NTOHL (0x6f727900),  // name = TypeCodeFactory
+};
+static CORBA::TypeCode _tc_TAO_tc_CORBA_TypeCodeFactory (CORBA::tk_objref, sizeof (_oc_CORBA_TypeCodeFactory), (char *) &_oc_CORBA_TypeCodeFactory, 0, sizeof (CORBA::TypeCodeFactory));
+TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
+TAO_NAMESPACE_BEGIN (CORBA)
+TAO_NAMESPACE_DEFINE (CORBA::TypeCode_ptr, _tc_TypeCodeFactory, &_tc_TAO_tc_CORBA_TypeCodeFactory)
+TAO_NAMESPACE_END
+void operator<<= (CORBA::Any &_tao_any, IR::DefinitionKind _tao_elem)
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_DefinitionKind,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::DefinitionKind &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_DefinitionKind, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_DefinitionKind, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -13828,35 +39990,32 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::DefinitionKind &_
   return 0;
 }
 
-CORBA::IRObject_ptr (*_TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer) (
+IR::Contained_ptr (*_TAO_collocation_IR_Contained_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::IRObject_ptr _tao_elem)
-{
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_IRObject,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::IRObject::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::Contained_ptr _tao_elem)
 {
-  CORBA::IRObject *tmp = ACE_static_cast(CORBA::IRObject*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_Contained, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::Contained::_duplicate (_tao_elem),
+        IR::Contained::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IRObject_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::Contained_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::IRObject::_nil ();
+    _tao_elem = IR::Contained::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_IRObject, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_Contained, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -13868,1117 +40027,1811 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IRObject_ptr &_ta
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::IRObject::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::Contained::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_IRObject,
+          IR::_tc_Contained,
           1,
           _tao_elem,
-          CORBA::IRObject::_tao_any_destructor
+          IR::Contained::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::IRObject::_nil ();
+    _tao_elem = IR::Contained::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::IRObject::_nil ();
+  _tao_elem = IR::Contained::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::IRObject,CORBA::IRObject_var>;
-  template class TAO_Object_Manager<CORBA::IRObject,CORBA::IRObject_var>;
+    template class TAO_Object_Field_T<IR::Contained,IR::Contained_var>;
+  template class TAO_Object_Manager<IR::Contained,IR::Contained_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::IRObject,CORBA::IRObject_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::IRObject,CORBA::IRObject_var>
+#  pragma instantiate TAO_Object_Field_T<IR::Contained,IR::Contained_var>
+#  pragma instantiate TAO_Object_Manager<IR::Contained,IR::Contained_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::Contained_ptr (*_TAO_collocation_CORBA_Contained_Stub_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::Contained_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, const IR::Contained::Description &_tao_elem) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_Contained,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::Contained::_tc_Description,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::Contained::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::Contained::Description *_tao_elem) // non copying
 {
-  CORBA::Contained *tmp = ACE_static_cast(CORBA::Contained*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::Contained::_tc_Description,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::Contained::Description::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::Contained::Description *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::Contained::Description*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::Contained::Description *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::Contained::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_Contained, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::Contained::_tc_Description, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
     ACE_TRY_CHECK;
-    TAO_InputCDR stream (
-        _tao_any._tao_get_cdr (),
-        _tao_any._tao_byte_order ()
-      );
-    CORBA::Object_var _tao_obj_var;
-    if (stream >> _tao_obj_var.out ())
+    if (_tao_any.any_owns_data ())
     {
-      _tao_elem = CORBA::Contained::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
-      ACE_TRY_CHECK;
-      ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_Contained,
-          1,
-          _tao_elem,
-          CORBA::Contained::_tao_any_destructor
+      _tao_elem = ACE_static_cast(
+          const IR::Contained::Description*,
+          _tao_any.value ()
         );
       return 1;
     }
+    else
+    {
+      IR::Contained::Description *tmp;
+      ACE_NEW_RETURN (tmp, IR::Contained::Description, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::Contained::_tc_Description,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::Contained::Description::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::Contained::_nil ();
-    return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::Contained::_nil ();
   return 0;
 }
 
-#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
-    defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::Contained,CORBA::Contained_var>;
-  template class TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var>;
-#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::Contained,CORBA::Contained_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var>
-#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
-
-void operator<<= (CORBA::Any &_tao_any, const CORBA::Contained::Description &_tao_elem) // copying
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::InterfaceDefSeq &_tao_elem
+  ) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::Contained::_tc_Description,
+        IR::_tc_InterfaceDefSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
+  }
 }
 
-void CORBA::Contained::Description::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::InterfaceDefSeq *_tao_elem) // non copying
 {
-  CORBA::Contained::Description *tmp = ACE_static_cast(CORBA::Contained::Description*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_InterfaceDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::InterfaceDefSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::Contained::Description *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::InterfaceDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::Contained::_tc_Description,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::Contained::Description::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::InterfaceDefSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Contained::Description *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::InterfaceDefSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::Contained::_tc_Description, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_InterfaceDefSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::Contained::Description *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::InterfaceDefSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::Contained::Description, 0);
+      IR::InterfaceDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::InterfaceDefSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::Contained::_tc_Description,
+            IR::_tc_InterfaceDefSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::Contained::Description::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::InterfaceDefSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Contained::Description *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::Contained::Description*&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::InterfaceDefSeq &_tao_elem
+    const IR::ValueDefSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_InterfaceDefSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ValueDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::InterfaceDefSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ValueDefSeq *_tao_elem) // non copying
 {
-  CORBA::InterfaceDefSeq *tmp = ACE_static_cast(CORBA::InterfaceDefSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ValueDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ValueDefSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDefSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ValueDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_InterfaceDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::InterfaceDefSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::ValueDefSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDefSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ValueDefSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_InterfaceDefSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ValueDefSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::InterfaceDefSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ValueDefSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::InterfaceDefSeq, 0);
+      IR::ValueDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ValueDefSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_InterfaceDefSeq,
+            IR::_tc_ValueDefSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::InterfaceDefSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ValueDefSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InterfaceDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::InterfaceDefSeq*&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::ValueDefSeq &_tao_elem
+    const IR::ComponentDefSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_ValueDefSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ComponentDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::ValueDefSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ComponentDefSeq *_tao_elem) // non copying
 {
-  CORBA::ValueDefSeq *tmp = ACE_static_cast(CORBA::ValueDefSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ComponentDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ComponentDefSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDefSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ComponentDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ValueDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ValueDefSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::ComponentDefSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDefSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ComponentDefSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ValueDefSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ComponentDefSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ValueDefSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ComponentDefSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ValueDefSeq, 0);
+      IR::ComponentDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ComponentDefSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ValueDefSeq,
+            IR::_tc_ComponentDefSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ValueDefSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ComponentDefSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::ValueDefSeq*&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::ContainedSeq &_tao_elem
+    const IR::ProvidesDefSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_ContainedSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ProvidesDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::ContainedSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ProvidesDefSeq *_tao_elem) // non copying
 {
-  CORBA::ContainedSeq *tmp = ACE_static_cast(CORBA::ContainedSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ProvidesDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ProvidesDefSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ContainedSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ProvidesDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ContainedSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ContainedSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::ProvidesDefSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContainedSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ProvidesDefSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ContainedSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ProvidesDefSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ContainedSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ProvidesDefSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ContainedSeq, 0);
+      IR::ProvidesDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ProvidesDefSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ContainedSeq,
+            IR::_tc_ProvidesDefSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ContainedSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ProvidesDefSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ContainedSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::ContainedSeq*&,_tao_elem);
-}
-
-void operator<<= (CORBA::Any &_tao_any, const CORBA::StructMember &_tao_elem) // copying
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::UsesDefSeq &_tao_elem
+  ) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_StructMember,
+        IR::_tc_UsesDefSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
+  }
 }
 
-void CORBA::StructMember::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::UsesDefSeq *_tao_elem) // non copying
 {
-  CORBA::StructMember *tmp = ACE_static_cast(CORBA::StructMember*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UsesDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::UsesDefSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::StructMember *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UsesDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_StructMember,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::StructMember::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::UsesDefSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMember *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::UsesDefSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_StructMember, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_UsesDefSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::StructMember *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::UsesDefSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::StructMember, 0);
+      IR::UsesDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::UsesDefSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_StructMember,
+            IR::_tc_UsesDefSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::StructMember::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::UsesDefSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::StructMember *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::StructMember *&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::StructMemberSeq &_tao_elem
+    const IR::HomeDefSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_StructMemberSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_HomeDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::StructMemberSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::HomeDefSeq *_tao_elem) // non copying
 {
-  CORBA::StructMemberSeq *tmp = ACE_static_cast(CORBA::StructMemberSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_HomeDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::HomeDefSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::StructMemberSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::HomeDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_StructMemberSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::StructMemberSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::HomeDefSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructMemberSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::HomeDefSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_StructMemberSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_HomeDefSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::StructMemberSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::HomeDefSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::StructMemberSeq, 0);
+      IR::HomeDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::HomeDefSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_StructMemberSeq,
+            IR::_tc_HomeDefSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::StructMemberSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::HomeDefSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::StructMemberSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::StructMemberSeq*&,_tao_elem);
-}
-
-void operator<<= (CORBA::Any &_tao_any, const CORBA::Initializer &_tao_elem) // copying
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::EmitsDefSeq &_tao_elem
+  ) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_Initializer,
+        IR::_tc_EmitsDefSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
+  }
 }
 
-void CORBA::Initializer::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::EmitsDefSeq *_tao_elem) // non copying
 {
-  CORBA::Initializer *tmp = ACE_static_cast(CORBA::Initializer*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_EmitsDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::EmitsDefSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::Initializer *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EmitsDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_Initializer,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::Initializer::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::EmitsDefSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Initializer *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::EmitsDefSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_Initializer, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_EmitsDefSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::Initializer *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::EmitsDefSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::Initializer, 0);
+      IR::EmitsDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::EmitsDefSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_Initializer,
+            IR::_tc_EmitsDefSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::Initializer::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::EmitsDefSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Initializer *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::Initializer*&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::InitializerSeq &_tao_elem
+    const IR::PublishesDefSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_InitializerSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_PublishesDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::InitializerSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::PublishesDefSeq *_tao_elem) // non copying
 {
-  CORBA::InitializerSeq *tmp =
-    ACE_static_cast(CORBA::InitializerSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_PublishesDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::PublishesDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PublishesDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::PublishesDefSeq*&,
+      _tao_elem
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::InitializerSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::PublishesDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_PublishesDefSeq, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::PublishesDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::PublishesDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::PublishesDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_PublishesDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::PublishesDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ConsumesDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_InitializerSeq,
+        IR::_tc_ConsumesDefSeq,
         TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::InitializerSeq::_tao_any_destructor
+        stream.begin ()
       );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ConsumesDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ConsumesDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ConsumesDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ConsumesDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::ConsumesDefSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InitializerSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ConsumesDefSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_InitializerSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ConsumesDefSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::InitializerSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ConsumesDefSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::InitializerSeq, 0);
+      IR::ConsumesDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ConsumesDefSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_InitializerSeq,
+            IR::_tc_ConsumesDefSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::InitializerSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ConsumesDefSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InitializerSeq *&_tao_elem)
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::FactoryDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_FactoryDefSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::FactoryDefSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_FactoryDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::FactoryDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::FactoryDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::FactoryDefSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::FactoryDefSeq *&_tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::InitializerSeq*&,_tao_elem);
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_FactoryDefSeq, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::FactoryDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::FactoryDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::FactoryDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_FactoryDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::FactoryDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::UnionMember &_tao_elem) // copying
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::FinderDefSeq &_tao_elem
+  ) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_UnionMember,
+        IR::_tc_FinderDefSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
+  }
 }
 
-void CORBA::UnionMember::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::FinderDefSeq *_tao_elem) // non copying
 {
-  CORBA::UnionMember *tmp = ACE_static_cast(CORBA::UnionMember*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_FinderDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::FinderDefSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::FinderDefSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::FinderDefSeq*&,
+      _tao_elem
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMember *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::FinderDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_FinderDefSeq, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::FinderDefSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::FinderDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::FinderDefSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_FinderDefSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::FinderDefSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ContainedSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_UnionMember,
+        IR::_tc_ContainedSeq,
         TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::UnionMember::_tao_any_destructor
+        stream.begin ()
       );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMember *&_tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::ContainedSeq *_tao_elem) // non copying
 {
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ContainedSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ContainedSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ContainedSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::ContainedSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ContainedSeq *&_tao_elem)
+{
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_UnionMember, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ContainedSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::UnionMember *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ContainedSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::UnionMember, 0);
+      IR::ContainedSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ContainedSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_UnionMember,
+            IR::_tc_ContainedSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::UnionMember::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ContainedSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::UnionMember *&_tao_elem)
+void operator<<= (CORBA::Any &_tao_any, const IR::StructMember &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_StructMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::StructMember *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_StructMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::StructMember::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::StructMember *&_tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::UnionMember*&,_tao_elem);
+  return _tao_any >>= ACE_const_cast(const IR::StructMember*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::StructMember *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_StructMember, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::StructMember*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::StructMember *tmp;
+      ACE_NEW_RETURN (tmp, IR::StructMember, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_StructMember,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::StructMember::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
 }
 
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::UnionMemberSeq &_tao_elem
+    const IR::StructMemberSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_StructMemberSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::StructMemberSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_StructMemberSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::StructMemberSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::StructMemberSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::StructMemberSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::StructMemberSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_StructMemberSeq, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_UnionMemberSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = ACE_static_cast(
+          const IR::StructMemberSeq*,
+          _tao_any.value ()
         );
+      return 1;
     }
+    else
+    {
+      IR::StructMemberSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::StructMemberSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_StructMemberSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::StructMemberSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
 }
 
-void CORBA::UnionMemberSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, const IR::Initializer &_tao_elem) // copying
 {
-  CORBA::UnionMemberSeq *tmp = ACE_static_cast(CORBA::UnionMemberSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_Initializer,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::Initializer *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_Initializer,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::Initializer::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::Initializer *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::Initializer*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::Initializer *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_Initializer, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::Initializer*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::Initializer *tmp;
+      ACE_NEW_RETURN (tmp, IR::Initializer, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_Initializer,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::Initializer::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::UnionMemberSeq *_tao_elem) // non copying
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::InitializerSeq &_tao_elem
+  ) // copying
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_UnionMemberSeq,
+        IR::_tc_InitializerSeq,
         TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::UnionMemberSeq::_tao_any_destructor
+        stream.begin ()
       );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionMemberSeq *&_tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::InitializerSeq *_tao_elem) // non copying
 {
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_InitializerSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::InitializerSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::InitializerSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::InitializerSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::InitializerSeq *&_tao_elem)
+{
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_UnionMemberSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_InitializerSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::UnionMemberSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::InitializerSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::UnionMemberSeq, 0);
+      IR::InitializerSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::InitializerSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_UnionMemberSeq,
+            IR::_tc_InitializerSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::UnionMemberSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::InitializerSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::UnionMemberSeq *&_tao_elem)
+void operator<<= (CORBA::Any &_tao_any, const IR::UnionMember &_tao_elem) // copying
 {
-  return _tao_any >>= ACE_const_cast(CORBA::UnionMemberSeq*&,_tao_elem);
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UnionMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::EnumMemberSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::UnionMember *_tao_elem) // non copying
 {
-  CORBA::EnumMemberSeq *tmp = ACE_static_cast(CORBA::EnumMemberSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UnionMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::UnionMember::_tao_any_destructor
+    );
 }
 
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const CORBA::EnumMemberSeq &_tao_elem
-  ) // copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UnionMember *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  return _tao_any >>= ACE_const_cast(const IR::UnionMember*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::UnionMember *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_UnionMember, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_EnumMemberSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = ACE_static_cast(
+          const IR::UnionMember*,
+          _tao_any.value ()
         );
+      return 1;
     }
+    else
+    {
+      IR::UnionMember *tmp;
+      ACE_NEW_RETURN (tmp, IR::UnionMember, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_UnionMember,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::UnionMember::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::EnumMemberSeq *_tao_elem) // non copying
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::UnionMemberSeq &_tao_elem
+  ) // copying
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_EnumMemberSeq,
+        IR::_tc_UnionMemberSeq,
         TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::EnumMemberSeq::_tao_any_destructor
+        stream.begin ()
       );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::UnionMemberSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UnionMemberSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::UnionMemberSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UnionMemberSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::UnionMemberSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumMemberSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::UnionMemberSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_EnumMemberSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_UnionMemberSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::EnumMemberSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::UnionMemberSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::EnumMemberSeq, 0);
+      IR::UnionMemberSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::UnionMemberSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_EnumMemberSeq,
+            IR::_tc_UnionMemberSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::EnumMemberSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::UnionMemberSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::EnumMemberSeq *&_tao_elem)
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::EnumMemberSeq &_tao_elem
+  ) // copying
 {
-  return _tao_any >>= ACE_const_cast(CORBA::EnumMemberSeq*&,_tao_elem);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_EnumMemberSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-CORBA::Container_ptr (*_TAO_collocation_CORBA_Container_Stub_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::Container_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::EnumMemberSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_EnumMemberSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::EnumMemberSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EnumMemberSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::EnumMemberSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::EnumMemberSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_EnumMemberSeq, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::EnumMemberSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_Container,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      IR::EnumMemberSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::EnumMemberSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
         );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_EnumMemberSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::EnumMemberSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
     }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
 }
 
-void CORBA::Container::_tao_any_destructor (void *x)
+IR::Container_ptr (*_TAO_collocation_IR_Container_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::Container_ptr _tao_elem)
 {
-  CORBA::Container *tmp = ACE_static_cast(CORBA::Container*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_Container, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::Container::_duplicate (_tao_elem),
+        IR::Container::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::Container_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::Container::_nil ();
+    _tao_elem = IR::Container::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_Container, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_Container, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -14990,242 +41843,233 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container_ptr &_t
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::Container::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::Container::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_Container,
+          IR::_tc_Container,
           1,
           _tao_elem,
-          CORBA::Container::_tao_any_destructor
+          IR::Container::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::Container::_nil ();
+    _tao_elem = IR::Container::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::Container::_nil ();
+  _tao_elem = IR::Container::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::Container,CORBA::Container_var>;
-  template class TAO_Object_Manager<CORBA::Container,CORBA::Container_var>;
+    template class TAO_Object_Field_T<IR::Container,IR::Container_var>;
+  template class TAO_Object_Manager<IR::Container,IR::Container_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::Container,CORBA::Container_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::Container,CORBA::Container_var>
+#  pragma instantiate TAO_Object_Field_T<IR::Container,IR::Container_var>
+#  pragma instantiate TAO_Object_Manager<IR::Container,IR::Container_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::Container::Description &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::Container::Description &_tao_elem) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::Container::_tc_Description,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::Container::_tc_Description,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::Container::Description::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::Container::Description *_tao_elem) // non copying
 {
-  CORBA::Container::Description *tmp = ACE_static_cast(CORBA::Container::Description*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::Container::_tc_Description,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::Container::Description::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::Container::Description *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::Container::Description *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::Container::_tc_Description,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::Container::Description::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(const IR::Container::Description*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::Description *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::Container::Description *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::Container::_tc_Description, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::Container::_tc_Description, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::Container::Description *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::Container::Description*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::Container::Description, 0);
+      IR::Container::Description *tmp;
+      ACE_NEW_RETURN (tmp, IR::Container::Description, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::Container::_tc_Description,
+            IR::Container::_tc_Description,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::Container::Description::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::Container::Description::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Container::Description *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::Container::Description*&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::Container::DescriptionSeq &_tao_elem
+    const IR::Container::DescriptionSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::Container::_tc_DescriptionSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::Container::_tc_DescriptionSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::Container::DescriptionSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::Container::DescriptionSeq *_tao_elem) // non copying
 {
-  CORBA::Container::DescriptionSeq *tmp = ACE_static_cast(CORBA::Container::DescriptionSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::Container::_tc_DescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::Container::DescriptionSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::Container::DescriptionSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::Container::DescriptionSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::Container::_tc_DescriptionSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::Container::DescriptionSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::Container::DescriptionSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Container::DescriptionSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::Container::DescriptionSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::Container::_tc_DescriptionSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::Container::_tc_DescriptionSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::Container::DescriptionSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::Container::DescriptionSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::Container::DescriptionSeq, 0);
+      IR::Container::DescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::Container::DescriptionSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::Container::_tc_DescriptionSeq,
+            IR::Container::_tc_DescriptionSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::Container::DescriptionSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::Container::DescriptionSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::Container::DescriptionSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::Container::DescriptionSeq*&,_tao_elem);
-}
-
-CORBA::IDLType_ptr (*_TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer) (
+IR::IDLType_ptr (*_TAO_collocation_IR_IDLType_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::IDLType_ptr _tao_elem)
-{
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_IDLType,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::IDLType::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::IDLType_ptr _tao_elem)
 {
-  CORBA::IDLType *tmp = ACE_static_cast(CORBA::IDLType*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_IDLType, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::IDLType::_duplicate (_tao_elem),
+        IR::IDLType::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IDLType_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::IDLType_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::IDLType::_nil ();
+    _tao_elem = IR::IDLType::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_IDLType, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_IDLType, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -15237,53 +42081,54 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IDLType_ptr &_tao
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::IDLType::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::IDLType::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_IDLType,
+          IR::_tc_IDLType,
           1,
           _tao_elem,
-          CORBA::IDLType::_tao_any_destructor
+          IR::IDLType::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::IDLType::_nil ();
+    _tao_elem = IR::IDLType::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::IDLType::_nil ();
+  _tao_elem = IR::IDLType::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::IDLType,CORBA::IDLType_var>;
-  template class TAO_Object_Manager<CORBA::IDLType,CORBA::IDLType_var>;
+    template class TAO_Object_Field_T<IR::IDLType,IR::IDLType_var>;
+  template class TAO_Object_Manager<IR::IDLType,IR::IDLType_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::IDLType,CORBA::IDLType_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::IDLType,CORBA::IDLType_var>
+#  pragma instantiate TAO_Object_Field_T<IR::IDLType,IR::IDLType_var>
+#  pragma instantiate TAO_Object_Manager<IR::IDLType,IR::IDLType_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::PrimitiveKind _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::PrimitiveKind _tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_PrimitiveKind,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_PrimitiveKind,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveKind &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PrimitiveKind &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_PrimitiveKind, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_PrimitiveKind, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -15305,35 +42150,32 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveKind &_t
   return 0;
 }
 
-CORBA::Repository_ptr (*_TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer) (
+IR::Repository_ptr (*_TAO_collocation_IR_Repository_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::Repository_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::Repository_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_Repository,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::Repository::_tao_any_destructor (void *x)
-{
-  CORBA::Repository *tmp = ACE_static_cast(CORBA::Repository*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_Repository, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::Repository::_duplicate (_tao_elem),
+        IR::Repository::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Repository_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::Repository_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::Repository::_nil ();
+    _tao_elem = IR::Repository::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_Repository, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_Repository, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -15345,65 +42187,131 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::Repository_ptr &_
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::Repository::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::Repository::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_Repository,
+          IR::_tc_Repository,
           1,
           _tao_elem,
-          CORBA::Repository::_tao_any_destructor
+          IR::Repository::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::Repository::_nil ();
+    _tao_elem = IR::Repository::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::Repository::_nil ();
+  _tao_elem = IR::Repository::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::Repository,CORBA::Repository_var>;
-  template class TAO_Object_Manager<CORBA::Repository,CORBA::Repository_var>;
+    template class TAO_Object_Field_T<IR::Repository,IR::Repository_var>;
+  template class TAO_Object_Manager<IR::Repository,IR::Repository_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::Repository,CORBA::Repository_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::Repository,CORBA::Repository_var>
+#  pragma instantiate TAO_Object_Field_T<IR::Repository,IR::Repository_var>
+#  pragma instantiate TAO_Object_Manager<IR::Repository,IR::Repository_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::ModuleDef_ptr (*_TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer) (
+IR::ComponentRepository_ptr (*_TAO_collocation_IR_ComponentRepository_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::ModuleDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::ComponentRepository_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ComponentRepository, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ComponentRepository::_duplicate (_tao_elem),
+        IR::ComponentRepository::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ComponentRepository_ptr &_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::ComponentRepository::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_ComponentRepository, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_ModuleDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = IR::ComponentRepository::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_ComponentRepository,
+          1,
+          _tao_elem,
+          IR::ComponentRepository::_tao_any_destructor
         );
+      return 1;
     }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::ComponentRepository::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::ComponentRepository::_nil ();
+  return 0;
 }
 
-void CORBA::ModuleDef::_tao_any_destructor (void *x)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::ComponentRepository,IR::ComponentRepository_var>;
+  template class TAO_Object_Manager<IR::ComponentRepository,IR::ComponentRepository_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::ComponentRepository,IR::ComponentRepository_var>
+#  pragma instantiate TAO_Object_Manager<IR::ComponentRepository,IR::ComponentRepository_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+IR::ModuleDef_ptr (*_TAO_collocation_IR_ModuleDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::ModuleDef_ptr _tao_elem)
 {
-  CORBA::ModuleDef *tmp = ACE_static_cast(CORBA::ModuleDef*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ModuleDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ModuleDef::_duplicate (_tao_elem),
+        IR::ModuleDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ModuleDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::ModuleDef::_nil ();
+    _tao_elem = IR::ModuleDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ModuleDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ModuleDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -15415,151 +42323,144 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDef_ptr &_t
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::ModuleDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::ModuleDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_ModuleDef,
+          IR::_tc_ModuleDef,
           1,
           _tao_elem,
-          CORBA::ModuleDef::_tao_any_destructor
+          IR::ModuleDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::ModuleDef::_nil ();
+    _tao_elem = IR::ModuleDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::ModuleDef::_nil ();
+  _tao_elem = IR::ModuleDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::ModuleDef,CORBA::ModuleDef_var>;
-  template class TAO_Object_Manager<CORBA::ModuleDef,CORBA::ModuleDef_var>;
+    template class TAO_Object_Field_T<IR::ModuleDef,IR::ModuleDef_var>;
+  template class TAO_Object_Manager<IR::ModuleDef,IR::ModuleDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::ModuleDef,CORBA::ModuleDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::ModuleDef,CORBA::ModuleDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::ModuleDef,IR::ModuleDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ModuleDef,IR::ModuleDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::ModuleDescription &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::ModuleDescription &_tao_elem) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ModuleDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ModuleDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::ModuleDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ModuleDescription *_tao_elem) // non copying
 {
-  CORBA::ModuleDescription *tmp = ACE_static_cast(CORBA::ModuleDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ModuleDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ModuleDescription::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ModuleDescription *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ModuleDescription *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ModuleDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ModuleDescription::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(const IR::ModuleDescription*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ModuleDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ModuleDescription *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ModuleDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ModuleDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ModuleDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ModuleDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ModuleDescription, 0);
+      IR::ModuleDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::ModuleDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ModuleDescription,
+            IR::_tc_ModuleDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ModuleDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ModuleDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ModuleDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::ModuleDescription *&,_tao_elem);
-}
-
-CORBA::ConstantDef_ptr (*_TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer) (
+IR::ConstantDef_ptr (*_TAO_collocation_IR_ConstantDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::ConstantDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::ConstantDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_ConstantDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::ConstantDef::_tao_any_destructor (void *x)
-{
-  CORBA::ConstantDef *tmp = ACE_static_cast(CORBA::ConstantDef*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ConstantDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ConstantDef::_duplicate (_tao_elem),
+        IR::ConstantDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ConstantDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::ConstantDef::_nil ();
+    _tao_elem = IR::ConstantDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ConstantDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ConstantDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -15571,151 +42472,144 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDef_ptr &
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::ConstantDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::ConstantDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_ConstantDef,
+          IR::_tc_ConstantDef,
           1,
           _tao_elem,
-          CORBA::ConstantDef::_tao_any_destructor
+          IR::ConstantDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::ConstantDef::_nil ();
+    _tao_elem = IR::ConstantDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::ConstantDef::_nil ();
+  _tao_elem = IR::ConstantDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::ConstantDef,CORBA::ConstantDef_var>;
-  template class TAO_Object_Manager<CORBA::ConstantDef,CORBA::ConstantDef_var>;
+    template class TAO_Object_Field_T<IR::ConstantDef,IR::ConstantDef_var>;
+  template class TAO_Object_Manager<IR::ConstantDef,IR::ConstantDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::ConstantDef,CORBA::ConstantDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::ConstantDef,CORBA::ConstantDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::ConstantDef,IR::ConstantDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ConstantDef,IR::ConstantDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::ConstantDescription &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::ConstantDescription &_tao_elem) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ConstantDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ConstantDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::ConstantDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ConstantDescription *_tao_elem) // non copying
 {
-  CORBA::ConstantDescription *tmp = ACE_static_cast(CORBA::ConstantDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ConstantDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ConstantDescription::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ConstantDescription *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ConstantDescription *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ConstantDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ConstantDescription::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(const IR::ConstantDescription*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ConstantDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ConstantDescription *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ConstantDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ConstantDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ConstantDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ConstantDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ConstantDescription, 0);
+      IR::ConstantDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::ConstantDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ConstantDescription,
+            IR::_tc_ConstantDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ConstantDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ConstantDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ConstantDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::ConstantDescription *&,_tao_elem);
-}
-
-CORBA::TypedefDef_ptr (*_TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer) (
+IR::TypedefDef_ptr (*_TAO_collocation_IR_TypedefDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::TypedefDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::TypedefDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_TypedefDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::TypedefDef::_tao_any_destructor (void *x)
-{
-  CORBA::TypedefDef *tmp = ACE_static_cast(CORBA::TypedefDef*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_TypedefDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::TypedefDef::_duplicate (_tao_elem),
+        IR::TypedefDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypedefDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::TypedefDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::TypedefDef::_nil ();
+    _tao_elem = IR::TypedefDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_TypedefDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_TypedefDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -15727,151 +42621,212 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypedefDef_ptr &_
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::TypedefDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::TypedefDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_TypedefDef,
+          IR::_tc_TypedefDef,
           1,
           _tao_elem,
-          CORBA::TypedefDef::_tao_any_destructor
+          IR::TypedefDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::TypedefDef::_nil ();
+    _tao_elem = IR::TypedefDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::TypedefDef::_nil ();
+  _tao_elem = IR::TypedefDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::TypedefDef,CORBA::TypedefDef_var>;
-  template class TAO_Object_Manager<CORBA::TypedefDef,CORBA::TypedefDef_var>;
+    template class TAO_Object_Field_T<IR::TypedefDef,IR::TypedefDef_var>;
+  template class TAO_Object_Manager<IR::TypedefDef,IR::TypedefDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::TypedefDef,CORBA::TypedefDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::TypedefDef,CORBA::TypedefDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::TypedefDef,IR::TypedefDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::TypedefDef,IR::TypedefDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::TypeDescription &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::TypeDescription &_tao_elem) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_TypeDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_TypeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::TypeDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::TypeDescription *_tao_elem) // non copying
 {
-  CORBA::TypeDescription *tmp = ACE_static_cast(CORBA::TypeDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_TypeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::TypeDescription::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::TypeDescription *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::TypeDescription *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_TypeDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::TypeDescription::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(const IR::TypeDescription*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypeDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::TypeDescription *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_TypeDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_TypeDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::TypeDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::TypeDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::TypeDescription, 0);
+      IR::TypeDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::TypeDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_TypeDescription,
+            IR::_tc_TypeDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::TypeDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::TypeDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::TypeDescription *&_tao_elem)
+IR::StructDef_ptr (*_TAO_collocation_IR_StructDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::StructDef_ptr _tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::TypeDescription *&,_tao_elem);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_StructDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::StructDef::_duplicate (_tao_elem),
+        IR::StructDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::StructDef_ptr (*_TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::StructDef_ptr _tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::StructDef_ptr &_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::StructDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_StructDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_StructDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = IR::StructDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_StructDef,
+          1,
+          _tao_elem,
+          IR::StructDef::_tao_any_destructor
         );
+      return 1;
     }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::StructDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::StructDef::_nil ();
+  return 0;
 }
 
-void CORBA::StructDef::_tao_any_destructor (void *x)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::StructDef,IR::StructDef_var>;
+  template class TAO_Object_Manager<IR::StructDef,IR::StructDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::StructDef,IR::StructDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::StructDef,IR::StructDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+IR::UnionDef_ptr (*_TAO_collocation_IR_UnionDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::UnionDef_ptr _tao_elem)
 {
-  CORBA::StructDef *tmp = ACE_static_cast(CORBA::StructDef*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_UnionDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::UnionDef::_duplicate (_tao_elem),
+        IR::UnionDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UnionDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::StructDef::_nil ();
+    _tao_elem = IR::UnionDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_StructDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_UnionDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -15883,65 +42838,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StructDef_ptr &_t
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::StructDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::UnionDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_StructDef,
+          IR::_tc_UnionDef,
           1,
           _tao_elem,
-          CORBA::StructDef::_tao_any_destructor
+          IR::UnionDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::StructDef::_nil ();
+    _tao_elem = IR::UnionDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::StructDef::_nil ();
+  _tao_elem = IR::UnionDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::StructDef,CORBA::StructDef_var>;
-  template class TAO_Object_Manager<CORBA::StructDef,CORBA::StructDef_var>;
+    template class TAO_Object_Field_T<IR::UnionDef,IR::UnionDef_var>;
+  template class TAO_Object_Manager<IR::UnionDef,IR::UnionDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::StructDef,CORBA::StructDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::StructDef,CORBA::StructDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::UnionDef,IR::UnionDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::UnionDef,IR::UnionDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::UnionDef_ptr (*_TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer) (
+IR::EnumDef_ptr (*_TAO_collocation_IR_EnumDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::UnionDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::EnumDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_UnionDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::UnionDef::_tao_any_destructor (void *x)
-{
-  CORBA::UnionDef *tmp = ACE_static_cast(CORBA::UnionDef*,x);
-  CORBA::release (tmp);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_EnumDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::EnumDef::_duplicate (_tao_elem),
+        IR::EnumDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EnumDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::UnionDef::_nil ();
+    _tao_elem = IR::EnumDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_UnionDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_EnumDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -15953,65 +42906,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::UnionDef_ptr &_ta
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::UnionDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::EnumDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_UnionDef,
+          IR::_tc_EnumDef,
           1,
           _tao_elem,
-          CORBA::UnionDef::_tao_any_destructor
+          IR::EnumDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::UnionDef::_nil ();
+    _tao_elem = IR::EnumDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::UnionDef::_nil ();
+  _tao_elem = IR::EnumDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::UnionDef,CORBA::UnionDef_var>;
-  template class TAO_Object_Manager<CORBA::UnionDef,CORBA::UnionDef_var>;
+    template class TAO_Object_Field_T<IR::EnumDef,IR::EnumDef_var>;
+  template class TAO_Object_Manager<IR::EnumDef,IR::EnumDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::UnionDef,CORBA::UnionDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::UnionDef,CORBA::UnionDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::EnumDef,IR::EnumDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::EnumDef,IR::EnumDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::EnumDef_ptr (*_TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer) (
+IR::AliasDef_ptr (*_TAO_collocation_IR_AliasDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::EnumDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::AliasDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_EnumDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::EnumDef::_tao_any_destructor (void *x)
-{
-  CORBA::EnumDef *tmp = ACE_static_cast(CORBA::EnumDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_AliasDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::AliasDef::_duplicate (_tao_elem),
+        IR::AliasDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::AliasDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::EnumDef::_nil ();
+    _tao_elem = IR::AliasDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_EnumDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_AliasDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16023,65 +42974,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::EnumDef_ptr &_tao
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::EnumDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::AliasDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_EnumDef,
+          IR::_tc_AliasDef,
           1,
           _tao_elem,
-          CORBA::EnumDef::_tao_any_destructor
+          IR::AliasDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::EnumDef::_nil ();
+    _tao_elem = IR::AliasDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::EnumDef::_nil ();
+  _tao_elem = IR::AliasDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::EnumDef,CORBA::EnumDef_var>;
-  template class TAO_Object_Manager<CORBA::EnumDef,CORBA::EnumDef_var>;
+    template class TAO_Object_Field_T<IR::AliasDef,IR::AliasDef_var>;
+  template class TAO_Object_Manager<IR::AliasDef,IR::AliasDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::EnumDef,CORBA::EnumDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::EnumDef,CORBA::EnumDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::AliasDef,IR::AliasDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::AliasDef,IR::AliasDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::AliasDef_ptr (*_TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer) (
+IR::NativeDef_ptr (*_TAO_collocation_IR_NativeDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::AliasDef_ptr _tao_elem)
-{
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_AliasDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::AliasDef::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::NativeDef_ptr _tao_elem)
 {
-  CORBA::AliasDef *tmp = ACE_static_cast(CORBA::AliasDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_NativeDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::NativeDef::_duplicate (_tao_elem),
+        IR::NativeDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AliasDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::NativeDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::AliasDef::_nil ();
+    _tao_elem = IR::NativeDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_AliasDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_NativeDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16093,65 +43042,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AliasDef_ptr &_ta
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::AliasDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::NativeDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_AliasDef,
+          IR::_tc_NativeDef,
           1,
           _tao_elem,
-          CORBA::AliasDef::_tao_any_destructor
+          IR::NativeDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::AliasDef::_nil ();
+    _tao_elem = IR::NativeDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::AliasDef::_nil ();
+  _tao_elem = IR::NativeDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::AliasDef,CORBA::AliasDef_var>;
-  template class TAO_Object_Manager<CORBA::AliasDef,CORBA::AliasDef_var>;
+    template class TAO_Object_Field_T<IR::NativeDef,IR::NativeDef_var>;
+  template class TAO_Object_Manager<IR::NativeDef,IR::NativeDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::AliasDef,CORBA::AliasDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::AliasDef,CORBA::AliasDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::NativeDef,IR::NativeDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::NativeDef,IR::NativeDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::PrimitiveDef_ptr (*_TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer) (
+IR::PrimitiveDef_ptr (*_TAO_collocation_IR_PrimitiveDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::PrimitiveDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::PrimitiveDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_PrimitiveDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::PrimitiveDef::_tao_any_destructor (void *x)
-{
-  CORBA::PrimitiveDef *tmp = ACE_static_cast(CORBA::PrimitiveDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_PrimitiveDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::PrimitiveDef::_duplicate (_tao_elem),
+        IR::PrimitiveDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PrimitiveDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::PrimitiveDef::_nil ();
+    _tao_elem = IR::PrimitiveDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_PrimitiveDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_PrimitiveDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16163,65 +43110,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::PrimitiveDef_ptr
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::PrimitiveDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::PrimitiveDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_PrimitiveDef,
+          IR::_tc_PrimitiveDef,
           1,
           _tao_elem,
-          CORBA::PrimitiveDef::_tao_any_destructor
+          IR::PrimitiveDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::PrimitiveDef::_nil ();
+    _tao_elem = IR::PrimitiveDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::PrimitiveDef::_nil ();
+  _tao_elem = IR::PrimitiveDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var>;
-  template class TAO_Object_Manager<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var>;
+    template class TAO_Object_Field_T<IR::PrimitiveDef,IR::PrimitiveDef_var>;
+  template class TAO_Object_Manager<IR::PrimitiveDef,IR::PrimitiveDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::PrimitiveDef,CORBA::PrimitiveDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::PrimitiveDef,IR::PrimitiveDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::PrimitiveDef,IR::PrimitiveDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::StringDef_ptr (*_TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer) (
+IR::StringDef_ptr (*_TAO_collocation_IR_StringDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::StringDef_ptr _tao_elem)
-{
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_StringDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::StringDef::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::StringDef_ptr _tao_elem)
 {
-  CORBA::StringDef *tmp = ACE_static_cast(CORBA::StringDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_StringDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::StringDef::_duplicate (_tao_elem),
+        IR::StringDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StringDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::StringDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::StringDef::_nil ();
+    _tao_elem = IR::StringDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_StringDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_StringDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16233,65 +43178,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::StringDef_ptr &_t
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::StringDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::StringDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_StringDef,
+          IR::_tc_StringDef,
           1,
           _tao_elem,
-          CORBA::StringDef::_tao_any_destructor
+          IR::StringDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::StringDef::_nil ();
+    _tao_elem = IR::StringDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::StringDef::_nil ();
+  _tao_elem = IR::StringDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::StringDef,CORBA::StringDef_var>;
-  template class TAO_Object_Manager<CORBA::StringDef,CORBA::StringDef_var>;
+    template class TAO_Object_Field_T<IR::StringDef,IR::StringDef_var>;
+  template class TAO_Object_Manager<IR::StringDef,IR::StringDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::StringDef,CORBA::StringDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::StringDef,CORBA::StringDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::StringDef,IR::StringDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::StringDef,IR::StringDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::WstringDef_ptr (*_TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer) (
+IR::WstringDef_ptr (*_TAO_collocation_IR_WstringDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::WstringDef_ptr _tao_elem)
-{
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_WstringDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::WstringDef::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::WstringDef_ptr _tao_elem)
 {
-  CORBA::WstringDef *tmp = ACE_static_cast(CORBA::WstringDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_WstringDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::WstringDef::_duplicate (_tao_elem),
+        IR::WstringDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::WstringDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::WstringDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::WstringDef::_nil ();
+    _tao_elem = IR::WstringDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_WstringDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_WstringDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16303,65 +43246,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::WstringDef_ptr &_
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::WstringDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::WstringDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_WstringDef,
+          IR::_tc_WstringDef,
           1,
           _tao_elem,
-          CORBA::WstringDef::_tao_any_destructor
+          IR::WstringDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::WstringDef::_nil ();
+    _tao_elem = IR::WstringDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::WstringDef::_nil ();
+  _tao_elem = IR::WstringDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::WstringDef,CORBA::WstringDef_var>;
-  template class TAO_Object_Manager<CORBA::WstringDef,CORBA::WstringDef_var>;
+    template class TAO_Object_Field_T<IR::WstringDef,IR::WstringDef_var>;
+  template class TAO_Object_Manager<IR::WstringDef,IR::WstringDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::WstringDef,CORBA::WstringDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::WstringDef,CORBA::WstringDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::WstringDef,IR::WstringDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::WstringDef,IR::WstringDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::FixedDef_ptr (*_TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer) (
+IR::FixedDef_ptr (*_TAO_collocation_IR_FixedDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::FixedDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::FixedDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_FixedDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::FixedDef::_tao_any_destructor (void *x)
-{
-  CORBA::FixedDef *tmp = ACE_static_cast(CORBA::FixedDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_FixedDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::FixedDef::_duplicate (_tao_elem),
+        IR::FixedDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::FixedDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::FixedDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::FixedDef::_nil ();
+    _tao_elem = IR::FixedDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_FixedDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_FixedDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16373,65 +43314,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::FixedDef_ptr &_ta
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::FixedDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::FixedDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_FixedDef,
+          IR::_tc_FixedDef,
           1,
           _tao_elem,
-          CORBA::FixedDef::_tao_any_destructor
+          IR::FixedDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::FixedDef::_nil ();
+    _tao_elem = IR::FixedDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::FixedDef::_nil ();
+  _tao_elem = IR::FixedDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::FixedDef,CORBA::FixedDef_var>;
-  template class TAO_Object_Manager<CORBA::FixedDef,CORBA::FixedDef_var>;
+    template class TAO_Object_Field_T<IR::FixedDef,IR::FixedDef_var>;
+  template class TAO_Object_Manager<IR::FixedDef,IR::FixedDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::FixedDef,CORBA::FixedDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::FixedDef,CORBA::FixedDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::FixedDef,IR::FixedDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::FixedDef,IR::FixedDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::SequenceDef_ptr (*_TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer) (
+IR::SequenceDef_ptr (*_TAO_collocation_IR_SequenceDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::SequenceDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::SequenceDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_SequenceDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::SequenceDef::_tao_any_destructor (void *x)
-{
-  CORBA::SequenceDef *tmp = ACE_static_cast(CORBA::SequenceDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_SequenceDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::SequenceDef::_duplicate (_tao_elem),
+        IR::SequenceDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SequenceDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::SequenceDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::SequenceDef::_nil ();
+    _tao_elem = IR::SequenceDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_SequenceDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_SequenceDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16443,65 +43382,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::SequenceDef_ptr &
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::SequenceDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::SequenceDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_SequenceDef,
+          IR::_tc_SequenceDef,
           1,
           _tao_elem,
-          CORBA::SequenceDef::_tao_any_destructor
+          IR::SequenceDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::SequenceDef::_nil ();
+    _tao_elem = IR::SequenceDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::SequenceDef::_nil ();
+  _tao_elem = IR::SequenceDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::SequenceDef,CORBA::SequenceDef_var>;
-  template class TAO_Object_Manager<CORBA::SequenceDef,CORBA::SequenceDef_var>;
+    template class TAO_Object_Field_T<IR::SequenceDef,IR::SequenceDef_var>;
+  template class TAO_Object_Manager<IR::SequenceDef,IR::SequenceDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::SequenceDef,CORBA::SequenceDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::SequenceDef,CORBA::SequenceDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::SequenceDef,IR::SequenceDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::SequenceDef,IR::SequenceDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::ArrayDef_ptr (*_TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer) (
+IR::ArrayDef_ptr (*_TAO_collocation_IR_ArrayDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::ArrayDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::ArrayDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_ArrayDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::ArrayDef::_tao_any_destructor (void *x)
-{
-  CORBA::ArrayDef *tmp = ACE_static_cast(CORBA::ArrayDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ArrayDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ArrayDef::_duplicate (_tao_elem),
+        IR::ArrayDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ArrayDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ArrayDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::ArrayDef::_nil ();
+    _tao_elem = IR::ArrayDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ArrayDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ArrayDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16513,65 +43450,63 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ArrayDef_ptr &_ta
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::ArrayDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::ArrayDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_ArrayDef,
+          IR::_tc_ArrayDef,
           1,
           _tao_elem,
-          CORBA::ArrayDef::_tao_any_destructor
+          IR::ArrayDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::ArrayDef::_nil ();
+    _tao_elem = IR::ArrayDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::ArrayDef::_nil ();
+  _tao_elem = IR::ArrayDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::ArrayDef,CORBA::ArrayDef_var>;
-  template class TAO_Object_Manager<CORBA::ArrayDef,CORBA::ArrayDef_var>;
+    template class TAO_Object_Field_T<IR::ArrayDef,IR::ArrayDef_var>;
+  template class TAO_Object_Manager<IR::ArrayDef,IR::ArrayDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::ArrayDef,CORBA::ArrayDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::ArrayDef,CORBA::ArrayDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::ArrayDef,IR::ArrayDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ArrayDef,IR::ArrayDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::ExceptionDef_ptr (*_TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer) (
+IR::ExceptionDef_ptr (*_TAO_collocation_IR_ExceptionDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr _tao_elem)
-{
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_ExceptionDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::ExceptionDef::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ExceptionDef_ptr _tao_elem)
 {
-  CORBA::ExceptionDef *tmp = ACE_static_cast(CORBA::ExceptionDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ExceptionDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ExceptionDef::_duplicate (_tao_elem),
+        IR::ExceptionDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ExceptionDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::ExceptionDef::_nil ();
+    _tao_elem = IR::ExceptionDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ExceptionDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ExceptionDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16583,140 +43518,313 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDef_ptr
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::ExceptionDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::ExceptionDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_ExceptionDef,
+          IR::_tc_ExceptionDef,
           1,
           _tao_elem,
-          CORBA::ExceptionDef::_tao_any_destructor
+          IR::ExceptionDef::_tao_any_destructor
         );
-      ACE_TRY_CHECK;
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::ExceptionDef::_nil ();
+    _tao_elem = IR::ExceptionDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::ExceptionDef::_nil ();
+  _tao_elem = IR::ExceptionDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::ExceptionDef,CORBA::ExceptionDef_var>;
-  template class TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var>;
+    template class TAO_Object_Field_T<IR::ExceptionDef,IR::ExceptionDef_var>;
+  template class TAO_Object_Manager<IR::ExceptionDef,IR::ExceptionDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::ExceptionDef,CORBA::ExceptionDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::ExceptionDef,IR::ExceptionDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ExceptionDef,IR::ExceptionDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::ExceptionDescription &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::ExceptionDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ExceptionDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ExceptionDescription *_tao_elem) // non copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ExceptionDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ExceptionDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ExceptionDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::ExceptionDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ExceptionDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_ExceptionDescription, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ExceptionDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ExceptionDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::ExceptionDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ExceptionDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ExceptionDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ExceptionDefSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_ExceptionDescription,
+        IR::_tc_ExceptionDefSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
+  }
 }
 
-void CORBA::ExceptionDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ExceptionDefSeq *_tao_elem) // non copying
 {
-  CORBA::ExceptionDescription *tmp = ACE_static_cast(CORBA::ExceptionDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ExceptionDefSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ExceptionDefSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDescription *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ExceptionDefSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ExceptionDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ExceptionDescription::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::ExceptionDefSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ExceptionDefSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ExceptionDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ExceptionDefSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ExceptionDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ExceptionDefSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ExceptionDescription, 0);
+      IR::ExceptionDefSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ExceptionDefSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ExceptionDescription,
+            IR::_tc_ExceptionDefSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ExceptionDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ExceptionDefSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExceptionDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::ExceptionDescription *&,_tao_elem);
-}
-
-void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeMode _tao_elem)
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ExcDescriptionSeq &_tao_elem
+  ) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_AttributeMode,
+        IR::_tc_ExcDescriptionSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ExcDescriptionSeq *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ExcDescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ExcDescriptionSeq::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ExcDescriptionSeq *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(
+      const IR::ExcDescriptionSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeMode &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ExcDescriptionSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_AttributeMode, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ExcDescriptionSeq, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ExcDescriptionSeq*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ExcDescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ExcDescriptionSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ExcDescriptionSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ExcDescriptionSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::AttributeMode _tao_elem)
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_AttributeMode,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::AttributeMode &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_AttributeMode, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16738,35 +43846,32 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeMode &_t
   return 0;
 }
 
-CORBA::AttributeDef_ptr (*_TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer) (
+IR::AttributeDef_ptr (*_TAO_collocation_IR_AttributeDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeDef_ptr _tao_elem)
-{
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_AttributeDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
-}
-
-void CORBA::AttributeDef::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::AttributeDef_ptr _tao_elem)
 {
-  CORBA::AttributeDef *tmp = ACE_static_cast(CORBA::AttributeDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_AttributeDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::AttributeDef::_duplicate (_tao_elem),
+        IR::AttributeDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::AttributeDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::AttributeDef::_nil ();
+    _tao_elem = IR::AttributeDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_AttributeDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_AttributeDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16778,139 +43883,135 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDef_ptr
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::AttributeDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::AttributeDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_AttributeDef,
+          IR::_tc_AttributeDef,
           1,
           _tao_elem,
-          CORBA::AttributeDef::_tao_any_destructor
+          IR::AttributeDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::AttributeDef::_nil ();
+    _tao_elem = IR::AttributeDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::AttributeDef::_nil ();
+  _tao_elem = IR::AttributeDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::AttributeDef,CORBA::AttributeDef_var>;
-  template class TAO_Object_Manager<CORBA::AttributeDef,CORBA::AttributeDef_var>;
+    template class TAO_Object_Field_T<IR::AttributeDef,IR::AttributeDef_var>;
+  template class TAO_Object_Manager<IR::AttributeDef,IR::AttributeDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::AttributeDef,CORBA::AttributeDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::AttributeDef,CORBA::AttributeDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::AttributeDef,IR::AttributeDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::AttributeDef,IR::AttributeDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::AttributeDescription &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::AttributeDescription &_tao_elem) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_AttributeDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_AttributeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::AttributeDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::AttributeDescription *_tao_elem) // non copying
 {
-  CORBA::AttributeDescription *tmp = ACE_static_cast(CORBA::AttributeDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_AttributeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::AttributeDescription::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::AttributeDescription *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::AttributeDescription *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_AttributeDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::AttributeDescription::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(const IR::AttributeDescription*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttributeDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::AttributeDescription *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_AttributeDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_AttributeDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::AttributeDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::AttributeDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::AttributeDescription, 0);
+      IR::AttributeDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::AttributeDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_AttributeDescription,
+            IR::_tc_AttributeDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::AttributeDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::AttributeDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::AttributeDescription *&_tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::OperationMode _tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::AttributeDescription *&,_tao_elem);
-}
-
-void operator<<= (CORBA::Any &_tao_any, CORBA::OperationMode _tao_elem)
-{
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_OperationMode,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_OperationMode,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationMode &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::OperationMode &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_OperationMode, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_OperationMode, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16932,23 +44033,23 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationMode &_t
   return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ParameterMode _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::ParameterMode _tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ParameterMode,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ParameterMode,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterMode &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ParameterMode &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ParameterMode, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ParameterMode, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -16970,486 +44071,707 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterMode &_t
   return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::ParameterDescription &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::ParameterDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ParameterDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ParameterDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ParameterDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ParameterDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ParameterDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::ParameterDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ParameterDescription *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_ParameterDescription, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ParameterDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ParameterDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::ParameterDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ParameterDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ParameterDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ParDescriptionSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_ParameterDescription,
+        IR::_tc_ParDescriptionSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
+  }
 }
 
-void CORBA::ParameterDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ParDescriptionSeq *_tao_elem) // non copying
 {
-  CORBA::ParameterDescription *tmp = ACE_static_cast(CORBA::ParameterDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ParDescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ParDescriptionSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ParameterDescription *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ParDescriptionSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ParameterDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ParameterDescription::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::ParDescriptionSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParameterDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ParDescriptionSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ParameterDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ParDescriptionSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ParameterDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ParDescriptionSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ParameterDescription, 0);
+      IR::ParDescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ParDescriptionSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ParameterDescription,
+            IR::_tc_ParDescriptionSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ParameterDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ParDescriptionSeq::_tao_any_destructor
           );
-        ACE_TRY_CHECK;
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ParameterDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::ParameterDescription *&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::ParDescriptionSeq &_tao_elem
+    const IR::ContextIdSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_ParDescriptionSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ContextIdSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::ParDescriptionSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ContextIdSeq *_tao_elem) // non copying
 {
-  CORBA::ParDescriptionSeq *tmp = ACE_static_cast(CORBA::ParDescriptionSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ContextIdSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ContextIdSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ParDescriptionSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ContextIdSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ParDescriptionSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ParDescriptionSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::ContextIdSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ParDescriptionSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ContextIdSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ParDescriptionSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ContextIdSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ParDescriptionSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ContextIdSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ParDescriptionSeq, 0);
+      IR::ContextIdSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ContextIdSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ParDescriptionSeq,
+            IR::_tc_ContextIdSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ParDescriptionSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ContextIdSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ParDescriptionSeq *&_tao_elem)
+IR::OperationDef_ptr (*_TAO_collocation_IR_OperationDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::OperationDef_ptr _tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::ParDescriptionSeq *&,_tao_elem);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_OperationDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::OperationDef::_duplicate (_tao_elem),
+        IR::OperationDef::_tao_any_destructor
+      );
+  }
 }
 
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const CORBA::ContextIdSeq &_tao_elem
-  ) // copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::OperationDef_ptr &_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::OperationDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_OperationDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_ContextIdSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = IR::OperationDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_OperationDef,
+          1,
+          _tao_elem,
+          IR::OperationDef::_tao_any_destructor
         );
+      return 1;
     }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::OperationDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::OperationDef::_nil ();
+  return 0;
 }
 
-void CORBA::ContextIdSeq::_tao_any_destructor (void *x)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::OperationDef,IR::OperationDef_var>;
+  template class TAO_Object_Manager<IR::OperationDef,IR::OperationDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::OperationDef,IR::OperationDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::OperationDef,IR::OperationDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::OperationDescription &_tao_elem) // copying
 {
-  CORBA::ContextIdSeq *tmp = ACE_static_cast(CORBA::ContextIdSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_OperationDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ContextIdSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, IR::OperationDescription *_tao_elem) // non copying
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ContextIdSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ContextIdSeq::_tao_any_destructor
-      );
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_OperationDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::OperationDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::OperationDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::OperationDescription*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ContextIdSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::OperationDescription *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ContextIdSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_OperationDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ContextIdSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::OperationDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ContextIdSeq, 0);
+      IR::OperationDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::OperationDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ContextIdSeq,
+            IR::_tc_OperationDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ContextIdSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::OperationDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ContextIdSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::ContextIdSeq *&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::ExceptionDefSeq &_tao_elem
+    const IR::RepositoryIdSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_ExceptionDefSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_RepositoryIdSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::ExceptionDefSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::RepositoryIdSeq *_tao_elem) // non copying
 {
-  CORBA::ExceptionDefSeq *tmp = ACE_static_cast(CORBA::ExceptionDefSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_RepositoryIdSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::RepositoryIdSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ExceptionDefSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::RepositoryIdSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ExceptionDefSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ExceptionDefSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::RepositoryIdSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExceptionDefSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::RepositoryIdSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ExceptionDefSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_RepositoryIdSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ExceptionDefSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::RepositoryIdSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ExceptionDefSeq, 0);
+      IR::RepositoryIdSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::RepositoryIdSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ExceptionDefSeq,
+            IR::_tc_RepositoryIdSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ExceptionDefSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::RepositoryIdSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExceptionDefSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::ExceptionDefSeq *&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::ExcDescriptionSeq &_tao_elem
+    const IR::OpDescriptionSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_ExcDescriptionSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_OpDescriptionSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::ExcDescriptionSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::OpDescriptionSeq *_tao_elem) // non copying
 {
-  CORBA::ExcDescriptionSeq *tmp = ACE_static_cast(CORBA::ExcDescriptionSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_OpDescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::OpDescriptionSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::OpDescriptionSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ExcDescriptionSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ExcDescriptionSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::OpDescriptionSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ExcDescriptionSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::OpDescriptionSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ExcDescriptionSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_OpDescriptionSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ExcDescriptionSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::OpDescriptionSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ExcDescriptionSeq, 0);
+      IR::OpDescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::OpDescriptionSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ExcDescriptionSeq,
+            IR::_tc_OpDescriptionSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ExcDescriptionSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::OpDescriptionSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ExcDescriptionSeq *&_tao_elem)
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::AttrDescriptionSeq &_tao_elem
+  ) // copying
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_AttrDescriptionSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::AttrDescriptionSeq *_tao_elem) // non copying
 {
-  return _tao_any >>= ACE_const_cast(CORBA::ExcDescriptionSeq *&,_tao_elem);
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_AttrDescriptionSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::AttrDescriptionSeq::_tao_any_destructor
+    );
 }
 
-CORBA::OperationDef_ptr (*_TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::OperationDef_ptr _tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::AttrDescriptionSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  return _tao_any >>= ACE_const_cast(
+      const IR::AttrDescriptionSeq*&,
+      _tao_elem
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::AttrDescriptionSeq *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_AttrDescriptionSeq, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_OperationDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = ACE_static_cast(
+          const IR::AttrDescriptionSeq*,
+          _tao_any.value ()
         );
+      return 1;
     }
+    else
+    {
+      IR::AttrDescriptionSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::AttrDescriptionSeq, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_AttrDescriptionSeq,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::AttrDescriptionSeq::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
 }
 
-void CORBA::OperationDef::_tao_any_destructor (void *x)
+IR::InterfaceDef_ptr (*_TAO_collocation_IR_InterfaceDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::InterfaceDef_ptr _tao_elem)
 {
-  CORBA::OperationDef *tmp = ACE_static_cast(CORBA::OperationDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_InterfaceDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::InterfaceDef::_duplicate (_tao_elem),
+        IR::InterfaceDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::InterfaceDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::OperationDef::_nil ();
+    _tao_elem = IR::InterfaceDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_OperationDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_InterfaceDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -17461,424 +44783,599 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDef_ptr
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::OperationDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::InterfaceDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_OperationDef,
+          IR::_tc_InterfaceDef,
           1,
           _tao_elem,
-          CORBA::OperationDef::_tao_any_destructor
+          IR::InterfaceDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::OperationDef::_nil ();
+    _tao_elem = IR::InterfaceDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::OperationDef::_nil ();
+  _tao_elem = IR::InterfaceDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::OperationDef,CORBA::OperationDef_var>;
-  template class TAO_Object_Manager<CORBA::OperationDef,CORBA::OperationDef_var>;
+    template class TAO_Object_Field_T<IR::InterfaceDef,IR::InterfaceDef_var>;
+  template class TAO_Object_Manager<IR::InterfaceDef,IR::InterfaceDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::OperationDef,CORBA::OperationDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::OperationDef,CORBA::OperationDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::InterfaceDef,IR::InterfaceDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::InterfaceDef,IR::InterfaceDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::OperationDescription &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::InterfaceDescription &_tao_elem) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_OperationDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_InterfaceDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::OperationDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::InterfaceDescription *_tao_elem) // non copying
 {
-  CORBA::OperationDescription *tmp = ACE_static_cast(CORBA::OperationDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_InterfaceDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::InterfaceDescription::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::OperationDescription *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::InterfaceDescription *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_OperationDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::OperationDescription::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(const IR::InterfaceDescription*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OperationDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::InterfaceDescription *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_OperationDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_InterfaceDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::OperationDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::InterfaceDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::OperationDescription, 0);
+      IR::InterfaceDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::InterfaceDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_OperationDescription,
+            IR::_tc_InterfaceDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::OperationDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::InterfaceDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::OperationDescription *&_tao_elem)
+void operator<<= (CORBA::Any &_tao_any, const IR::ValueMember &_tao_elem) // copying
 {
-  return _tao_any >>= ACE_const_cast(CORBA::OperationDescription *&,_tao_elem);
-}
-
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const CORBA::RepositoryIdSeq &_tao_elem
-  ) // copying
-{
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_RepositoryIdSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ValueMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::RepositoryIdSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ValueMember *_tao_elem) // non copying
 {
-  CORBA::RepositoryIdSeq *tmp = ACE_static_cast(CORBA::RepositoryIdSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ValueMember,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ValueMember::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::RepositoryIdSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ValueMember *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_RepositoryIdSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::RepositoryIdSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(const IR::ValueMember*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::RepositoryIdSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ValueMember *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_RepositoryIdSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ValueMember, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::RepositoryIdSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ValueMember*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::RepositoryIdSeq, 0);
+      IR::ValueMember *tmp;
+      ACE_NEW_RETURN (tmp, IR::ValueMember, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_RepositoryIdSeq,
+            IR::_tc_ValueMember,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::RepositoryIdSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ValueMember::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::RepositoryIdSeq *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::RepositoryIdSeq *&,_tao_elem);
-}
-
 void operator<<= (
     CORBA::Any &_tao_any,
-    const CORBA::OpDescriptionSeq &_tao_elem
+    const IR::ValueMemberSeq &_tao_elem
   ) // copying
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
-    {
-      _tao_any._tao_replace (
-          CORBA::_tc_OpDescriptionSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
-        );
-    }
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ValueMemberSeq,
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin ()
+      );
+  }
 }
 
-void CORBA::OpDescriptionSeq::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ValueMemberSeq *_tao_elem) // non copying
 {
-  CORBA::OpDescriptionSeq *tmp = ACE_static_cast(CORBA::OpDescriptionSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ValueMemberSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ValueMemberSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::OpDescriptionSeq *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ValueMemberSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_OpDescriptionSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::OpDescriptionSeq::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::ValueMemberSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::OpDescriptionSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ValueMemberSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_OpDescriptionSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ValueMemberSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::OpDescriptionSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ValueMemberSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::OpDescriptionSeq, 0);
+      IR::ValueMemberSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ValueMemberSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_OpDescriptionSeq,
+            IR::_tc_ValueMemberSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::OpDescriptionSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ValueMemberSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::OpDescriptionSeq *&_tao_elem)
+IR::ValueMemberDef_ptr (*_TAO_collocation_IR_ValueMemberDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::ValueMemberDef_ptr _tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::OpDescriptionSeq *&,_tao_elem);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ValueMemberDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ValueMemberDef::_duplicate (_tao_elem),
+        IR::ValueMemberDef::_tao_any_destructor
+      );
+  }
 }
 
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const CORBA::AttrDescriptionSeq &_tao_elem
-  ) // copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ValueMemberDef_ptr &_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::ValueMemberDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_ValueMemberDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_AttrDescriptionSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = IR::ValueMemberDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_ValueMemberDef,
+          1,
+          _tao_elem,
+          IR::ValueMemberDef::_tao_any_destructor
         );
+      return 1;
     }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::ValueMemberDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::ValueMemberDef::_nil ();
+  return 0;
 }
 
-void CORBA::AttrDescriptionSeq::_tao_any_destructor (void *x)
-{
-  CORBA::AttrDescriptionSeq *tmp = ACE_static_cast(CORBA::AttrDescriptionSeq*,x);
-  delete tmp;
-}
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::ValueMemberDef,IR::ValueMemberDef_var>;
+  template class TAO_Object_Manager<IR::ValueMemberDef,IR::ValueMemberDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::ValueMemberDef,IR::ValueMemberDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ValueMemberDef,IR::ValueMemberDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::AttrDescriptionSeq *_tao_elem) // non copying
+IR::ValueDef_ptr (*_TAO_collocation_IR_ValueDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::ValueDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_AttrDescriptionSeq,
+        IR::_tc_ValueDef, 
         TAO_ENCAP_BYTE_ORDER,
         stream.begin (),
         1,
-        _tao_elem,
-        CORBA::AttrDescriptionSeq::_tao_any_destructor
+        IR::ValueDef::_duplicate (_tao_elem),
+        IR::ValueDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ValueDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::ValueDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_ValueDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
       );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
+    {
+      _tao_elem = IR::ValueDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_ValueDef,
+          1,
+          _tao_elem,
+          IR::ValueDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::ValueDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::ValueDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::ValueDef,IR::ValueDef_var>;
+  template class TAO_Object_Manager<IR::ValueDef,IR::ValueDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::ValueDef,IR::ValueDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ValueDef,IR::ValueDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::ValueDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ValueDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::ValueDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ValueDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ValueDescription::_tao_any_destructor
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::AttrDescriptionSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ValueDescription *&_tao_elem)
 {
+  return _tao_any >>= ACE_const_cast(const IR::ValueDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ValueDescription *&_tao_elem)
+{
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_AttrDescriptionSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ValueDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::AttrDescriptionSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ValueDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::AttrDescriptionSeq, 0);
+      IR::ValueDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::ValueDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_AttrDescriptionSeq,
+            IR::_tc_ValueDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::AttrDescriptionSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ValueDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::AttrDescriptionSeq *&_tao_elem)
+IR::ValueBoxDef_ptr (*_TAO_collocation_IR_ValueBoxDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::ValueBoxDef_ptr _tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::AttrDescriptionSeq *&,_tao_elem);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ValueBoxDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ValueBoxDef::_duplicate (_tao_elem),
+        IR::ValueBoxDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDef_ptr _tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ValueBoxDef_ptr &_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::ValueBoxDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_ValueBoxDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_InterfaceDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = IR::ValueBoxDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_ValueBoxDef,
+          1,
+          _tao_elem,
+          IR::ValueBoxDef::_tao_any_destructor
         );
+      return 1;
     }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::ValueBoxDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::ValueBoxDef::_nil ();
+  return 0;
 }
 
-void CORBA::InterfaceDef::_tao_any_destructor (void *x)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::ValueBoxDef,IR::ValueBoxDef_var>;
+  template class TAO_Object_Manager<IR::ValueBoxDef,IR::ValueBoxDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::ValueBoxDef,IR::ValueBoxDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ValueBoxDef,IR::ValueBoxDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+IR::ProvidesDef_ptr (*_TAO_collocation_IR_ProvidesDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::ProvidesDef_ptr _tao_elem)
 {
-  CORBA::InterfaceDef *tmp = ACE_static_cast(CORBA::InterfaceDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ProvidesDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ProvidesDef::_duplicate (_tao_elem),
+        IR::ProvidesDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ProvidesDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::InterfaceDef::_nil ();
+    _tao_elem = IR::ProvidesDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_InterfaceDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ProvidesDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -17890,415 +45387,688 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef_ptr
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::InterfaceDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::ProvidesDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_InterfaceDef,
+          IR::_tc_ProvidesDef,
           1,
           _tao_elem,
-          CORBA::InterfaceDef::_tao_any_destructor
+          IR::ProvidesDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::InterfaceDef::_nil ();
+    _tao_elem = IR::ProvidesDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::InterfaceDef::_nil ();
+  _tao_elem = IR::ProvidesDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::InterfaceDef,CORBA::InterfaceDef_var>;
-  template class TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var>;
+    template class TAO_Object_Field_T<IR::ProvidesDef,IR::ProvidesDef_var>;
+  template class TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::ProvidesDef,IR::ProvidesDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::InterfaceDef::FullInterfaceDescription &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::ProvidesDescription &_tao_elem) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::InterfaceDef::_tc_FullInterfaceDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ProvidesDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void
-CORBA::InterfaceDef::FullInterfaceDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ProvidesDescription *_tao_elem) // non copying
 {
-  CORBA::InterfaceDef::FullInterfaceDescription *tmp = ACE_static_cast(CORBA::InterfaceDef::FullInterfaceDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ProvidesDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ProvidesDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ProvidesDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::ProvidesDescription*&,_tao_elem);
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDef::FullInterfaceDescription *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ProvidesDescription *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_ProvidesDescription, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ProvidesDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ProvidesDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::ProvidesDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ProvidesDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ProvidesDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+IR::UsesDef_ptr (*_TAO_collocation_IR_UsesDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::UsesDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::InterfaceDef::_tc_FullInterfaceDescription,
+        IR::_tc_UsesDef, 
         TAO_ENCAP_BYTE_ORDER,
         stream.begin (),
         1,
-        _tao_elem,
-        CORBA::InterfaceDef::FullInterfaceDescription::_tao_any_destructor
+        IR::UsesDef::_duplicate (_tao_elem),
+        IR::UsesDef::_tao_any_destructor
       );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDef::FullInterfaceDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UsesDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
+    _tao_elem = IR::UsesDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::InterfaceDef::_tc_FullInterfaceDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_UsesDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
+    {
+      _tao_elem = IR::UsesDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_UsesDef,
+          1,
+          _tao_elem,
+          IR::UsesDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::UsesDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::UsesDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::UsesDef,IR::UsesDef_var>;
+  template class TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::UsesDef,IR::UsesDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::UsesDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UsesDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::UsesDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UsesDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::UsesDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UsesDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::UsesDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::UsesDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_UsesDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::InterfaceDef::FullInterfaceDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::UsesDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::InterfaceDef::FullInterfaceDescription, 0);
+      IR::UsesDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::UsesDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::InterfaceDef::_tc_FullInterfaceDescription,
+            IR::_tc_UsesDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::InterfaceDef::FullInterfaceDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::UsesDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InterfaceDef::FullInterfaceDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::InterfaceDef::FullInterfaceDescription *&,_tao_elem);
-}
-
-void operator<<= (CORBA::Any &_tao_any, const CORBA::InterfaceDescription &_tao_elem) // copying
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::ProvidesDescSeq &_tao_elem
+  ) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_InterfaceDescription,
+        IR::_tc_ProvidesDescSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
+  }
 }
 
-void CORBA::InterfaceDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ProvidesDescSeq *_tao_elem) // non copying
 {
-  CORBA::InterfaceDescription *tmp = ACE_static_cast(CORBA::InterfaceDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ProvidesDescSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ProvidesDescSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::InterfaceDescription *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ProvidesDescSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_InterfaceDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::InterfaceDescription::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::ProvidesDescSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::InterfaceDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ProvidesDescSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_InterfaceDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ProvidesDescSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::InterfaceDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::ProvidesDescSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::InterfaceDescription, 0);
+      IR::ProvidesDescSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::ProvidesDescSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_InterfaceDescription,
+            IR::_tc_ProvidesDescSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::InterfaceDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::ProvidesDescSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::InterfaceDescription *&_tao_elem)
-{
-  return _tao_any >>= ACE_const_cast(CORBA::InterfaceDescription *&,_tao_elem);
-}
-
-void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueMember &_tao_elem) // copying
+void operator<<= (
+    CORBA::Any &_tao_any,
+    const IR::UsesDescSeq &_tao_elem
+  ) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_ValueMember,
+        IR::_tc_UsesDescSeq,
         TAO_ENCAP_BYTE_ORDER,
         stream.begin ()
       );
+  }
 }
 
-void CORBA::ValueMember::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::UsesDescSeq *_tao_elem) // non copying
 {
-  CORBA::ValueMember *tmp = ACE_static_cast(CORBA::ValueMember*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_UsesDescSeq,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::UsesDescSeq::_tao_any_destructor
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMember *_tao_elem) // non copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::UsesDescSeq *&_tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ValueMember,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ValueMember::_tao_any_destructor
-      );
+  return _tao_any >>= ACE_const_cast(
+      const IR::UsesDescSeq*&,
+      _tao_elem
+    );
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMember *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::UsesDescSeq *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ValueMember, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_UsesDescSeq, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ValueMember *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::UsesDescSeq*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ValueMember, 0);
+      IR::UsesDescSeq *tmp;
+      ACE_NEW_RETURN (tmp, IR::UsesDescSeq, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ValueMember,
+            IR::_tc_UsesDescSeq,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ValueMember::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::UsesDescSeq::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueMember *&_tao_elem)
+IR::EventDef_ptr (*_TAO_collocation_IR_EventDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::EventDef_ptr _tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::ValueMember *&,_tao_elem);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_EventDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::EventDef::_duplicate (_tao_elem),
+        IR::EventDef::_tao_any_destructor
+      );
+  }
 }
 
-void operator<<= (
-    CORBA::Any &_tao_any,
-    const CORBA::ValueMemberSeq &_tao_elem
-  ) // copying
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EventDef_ptr &_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::EventDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_EventDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_ValueMemberSeq,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = IR::EventDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_EventDef,
+          1,
+          _tao_elem,
+          IR::EventDef::_tao_any_destructor
         );
+      return 1;
     }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::EventDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::EventDef::_nil ();
+  return 0;
 }
 
-void CORBA::ValueMemberSeq::_tao_any_destructor (void *x)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::EventDef,IR::EventDef_var>;
+  template class TAO_Object_Manager<IR::EventDef,IR::EventDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::EventDef,IR::EventDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::EventDef,IR::EventDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::EventDescription &_tao_elem) // copying
 {
-  CORBA::ValueMemberSeq *tmp = ACE_static_cast(CORBA::ValueMemberSeq*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_EventDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMemberSeq *_tao_elem) // non copying
+void operator<<= (CORBA::Any &_tao_any, IR::EventDescription *_tao_elem) // non copying
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
-    _tao_any._tao_replace (
-        CORBA::_tc_ValueMemberSeq,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin (),
-        1,
-        _tao_elem,
-        CORBA::ValueMemberSeq::_tao_any_destructor
-      );
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_EventDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::EventDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EventDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::EventDescription*&,_tao_elem);
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberSeq *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::EventDescription *&_tao_elem)
 {
+  _tao_elem = 0;
   ACE_TRY_NEW_ENV
   {
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ValueMemberSeq, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_EventDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ValueMemberSeq *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::EventDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ValueMemberSeq, 0);
+      IR::EventDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::EventDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ValueMemberSeq,
+            IR::_tc_EventDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ValueMemberSeq::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::EventDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueMemberSeq *&_tao_elem)
+IR::EmitsDef_ptr (*_TAO_collocation_IR_EmitsDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::EmitsDef_ptr _tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::ValueMemberSeq *&,_tao_elem);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_EmitsDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::EmitsDef::_duplicate (_tao_elem),
+        IR::EmitsDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::ValueMemberDef_ptr _tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::EmitsDef_ptr &_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::EmitsDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_EmitsDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_ValueMemberDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = IR::EmitsDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_EmitsDef,
+          1,
+          _tao_elem,
+          IR::EmitsDef::_tao_any_destructor
         );
+      return 1;
     }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::EmitsDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::EmitsDef::_nil ();
+  return 0;
 }
 
-void CORBA::ValueMemberDef::_tao_any_destructor (void *x)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::EmitsDef,IR::EmitsDef_var>;
+  template class TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::EmitsDef,IR::EmitsDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+IR::PublishesDef_ptr (*_TAO_collocation_IR_PublishesDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::PublishesDef_ptr _tao_elem)
 {
-  CORBA::ValueMemberDef *tmp = ACE_static_cast(CORBA::ValueMemberDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_PublishesDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::PublishesDef::_duplicate (_tao_elem),
+        IR::PublishesDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PublishesDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::ValueMemberDef::_nil ();
+    _tao_elem = IR::PublishesDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ValueMemberDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_PublishesDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -18310,65 +46080,131 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueMemberDef_pt
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::ValueMemberDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::PublishesDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_ValueMemberDef,
+          IR::_tc_PublishesDef,
           1,
           _tao_elem,
-          CORBA::ValueMemberDef::_tao_any_destructor
+          IR::PublishesDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::ValueMemberDef::_nil ();
+    _tao_elem = IR::PublishesDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::ValueMemberDef::_nil ();
+  _tao_elem = IR::PublishesDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var>;
-  template class TAO_Object_Manager<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var>;
+    template class TAO_Object_Field_T<IR::PublishesDef,IR::PublishesDef_var>;
+  template class TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::ValueMemberDef,CORBA::ValueMemberDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::PublishesDef,IR::PublishesDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-CORBA::ValueDef_ptr (*_TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer) (
+IR::ConsumesDef_ptr (*_TAO_collocation_IR_ConsumesDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDef_ptr _tao_elem)
+void operator<<= (CORBA::Any &_tao_any, IR::ConsumesDef_ptr _tao_elem)
+{
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ConsumesDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ConsumesDef::_duplicate (_tao_elem),
+        IR::ConsumesDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ConsumesDef_ptr &_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::ConsumesDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_ConsumesDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_ValueDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = IR::ConsumesDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_ConsumesDef,
+          1,
+          _tao_elem,
+          IR::ConsumesDef::_tao_any_destructor
         );
+      return 1;
     }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::ConsumesDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::ConsumesDef::_nil ();
+  return 0;
 }
 
-void CORBA::ValueDef::_tao_any_destructor (void *x)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::ConsumesDef,IR::ConsumesDef_var>;
+  template class TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::ConsumesDef,IR::ConsumesDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+IR::ComponentDef_ptr (*_TAO_collocation_IR_ComponentDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::ComponentDef_ptr _tao_elem)
 {
-  CORBA::ValueDef *tmp = ACE_static_cast(CORBA::ValueDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_ComponentDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::ComponentDef::_duplicate (_tao_elem),
+        IR::ComponentDef::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ComponentDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::ValueDef::_nil ();
+    _tao_elem = IR::ComponentDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ValueDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_ComponentDef, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -18380,237 +46216,646 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef_ptr &_ta
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::ValueDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = IR::ComponentDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_ValueDef,
+          IR::_tc_ComponentDef,
           1,
           _tao_elem,
-          CORBA::ValueDef::_tao_any_destructor
+          IR::ComponentDef::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::ValueDef::_nil ();
+    _tao_elem = IR::ComponentDef::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::ValueDef::_nil ();
+  _tao_elem = IR::ComponentDef::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::ValueDef,CORBA::ValueDef_var>;
-  template class TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var>;
+    template class TAO_Object_Field_T<IR::ComponentDef,IR::ComponentDef_var>;
+  template class TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::ValueDef,CORBA::ValueDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var>
+#  pragma instantiate TAO_Object_Field_T<IR::ComponentDef,IR::ComponentDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueDef::FullValueDescription &_tao_elem) // copying
+void operator<<= (CORBA::Any &_tao_any, const IR::ComponentDescription &_tao_elem) // copying
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
-    _tao_any._tao_replace (
-        CORBA::ValueDef::_tc_FullValueDescription,
-        TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
-      );
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ComponentDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
 }
 
-void CORBA::ValueDef::FullValueDescription::_tao_any_destructor (void *x)
+void operator<<= (CORBA::Any &_tao_any, IR::ComponentDescription *_tao_elem) // non copying
 {
-  CORBA::ValueDef::FullValueDescription *tmp = ACE_static_cast(CORBA::ValueDef::FullValueDescription*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_ComponentDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::ComponentDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::ComponentDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::ComponentDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::ComponentDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_ComponentDescription, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    if (_tao_any.any_owns_data ())
+    {
+      _tao_elem = ACE_static_cast(
+          const IR::ComponentDescription*,
+          _tao_any.value ()
+        );
+      return 1;
+    }
+    else
+    {
+      IR::ComponentDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::ComponentDescription, 0);
+      TAO_InputCDR stream (
+          _tao_any._tao_get_cdr (),
+          _tao_any._tao_byte_order ()
+        );
+      if (stream >> *tmp)
+      {
+        ((CORBA::Any *)&_tao_any)->_tao_replace (
+            IR::_tc_ComponentDescription,
+            1,
+            ACE_static_cast (void *, tmp),
+            IR::ComponentDescription::_tao_any_destructor
+          );
+        _tao_elem = tmp;
+        return 1;
+      }
+      else
+      {
+        delete tmp;
+      }
+    }
+  }
+  ACE_CATCHANY
+  {
+  }
+  ACE_ENDTRY;
+  return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDef::FullValueDescription *_tao_elem) // non copying
+IR::PrimaryKeyDef_ptr (*_TAO_collocation_IR_PrimaryKeyDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::PrimaryKeyDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::ValueDef::_tc_FullValueDescription,
+        IR::_tc_PrimaryKeyDef, 
         TAO_ENCAP_BYTE_ORDER,
         stream.begin (),
         1,
-        _tao_elem,
-        CORBA::ValueDef::FullValueDescription::_tao_any_destructor
+        IR::PrimaryKeyDef::_duplicate (_tao_elem),
+        IR::PrimaryKeyDef::_tao_any_destructor
       );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDef::FullValueDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PrimaryKeyDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
+    _tao_elem = IR::PrimaryKeyDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::ValueDef::_tc_FullValueDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_PrimaryKeyDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
+    {
+      _tao_elem = IR::PrimaryKeyDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_PrimaryKeyDef,
+          1,
+          _tao_elem,
+          IR::PrimaryKeyDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::PrimaryKeyDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::PrimaryKeyDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::PrimaryKeyDef,IR::PrimaryKeyDef_var>;
+  template class TAO_Object_Manager<IR::PrimaryKeyDef,IR::PrimaryKeyDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::PrimaryKeyDef,IR::PrimaryKeyDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::PrimaryKeyDef,IR::PrimaryKeyDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::PrimaryKeyDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_PrimaryKeyDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::PrimaryKeyDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_PrimaryKeyDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::PrimaryKeyDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::PrimaryKeyDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::PrimaryKeyDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::PrimaryKeyDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_PrimaryKeyDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ValueDef::FullValueDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::PrimaryKeyDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ValueDef::FullValueDescription, 0);
+      IR::PrimaryKeyDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::PrimaryKeyDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::ValueDef::_tc_FullValueDescription,
+            IR::_tc_PrimaryKeyDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ValueDef::FullValueDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::PrimaryKeyDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueDef::FullValueDescription *&_tao_elem)
+IR::FactoryDef_ptr (*_TAO_collocation_IR_FactoryDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::FactoryDef_ptr _tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::ValueDef::FullValueDescription *&,_tao_elem);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        IR::_tc_FactoryDef, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        IR::FactoryDef::_duplicate (_tao_elem),
+        IR::FactoryDef::_tao_any_destructor
+      );
+  }
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::FactoryDef_ptr &_tao_elem)
+{
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::FactoryDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_FactoryDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
+    {
+      _tao_elem = IR::FactoryDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_FactoryDef,
+          1,
+          _tao_elem,
+          IR::FactoryDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::FactoryDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::FactoryDef::_nil ();
+  return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, const CORBA::ValueDescription &_tao_elem) // copying
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::FactoryDef,IR::FactoryDef_var>;
+  template class TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::FactoryDef,IR::FactoryDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+IR::FinderDef_ptr (*_TAO_collocation_IR_FinderDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::FinderDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << _tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_ValueDescription,
+        IR::_tc_FinderDef, 
         TAO_ENCAP_BYTE_ORDER,
-        stream.begin ()
+        stream.begin (),
+        1,
+        IR::FinderDef::_duplicate (_tao_elem),
+        IR::FinderDef::_tao_any_destructor
       );
+  }
 }
 
-void CORBA::ValueDescription::_tao_any_destructor (void *x)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::FinderDef_ptr &_tao_elem)
 {
-  CORBA::ValueDescription *tmp = ACE_static_cast(CORBA::ValueDescription*,x);
-  delete tmp;
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = IR::FinderDef::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_FinderDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
+    {
+      _tao_elem = IR::FinderDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_FinderDef,
+          1,
+          _tao_elem,
+          IR::FinderDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::FinderDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::FinderDef::_nil ();
+  return 0;
 }
 
-void operator<<= (CORBA::Any &_tao_any, CORBA::ValueDescription *_tao_elem) // non copying
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::FinderDef,IR::FinderDef_var>;
+  template class TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::FinderDef,IR::FinderDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+IR::HomeDef_ptr (*_TAO_collocation_IR_HomeDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, IR::HomeDef_ptr _tao_elem)
 {
-    TAO_OutputCDR stream;
-    stream << *_tao_elem;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
     _tao_any._tao_replace (
-        CORBA::_tc_ValueDescription,
+        IR::_tc_HomeDef, 
         TAO_ENCAP_BYTE_ORDER,
         stream.begin (),
         1,
-        _tao_elem,
-        CORBA::ValueDescription::_tao_any_destructor
+        IR::HomeDef::_duplicate (_tao_elem),
+        IR::HomeDef::_tao_any_destructor
       );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueDescription *&_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::HomeDef_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
+    _tao_elem = IR::HomeDef::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ValueDescription, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (IR::_tc_HomeDef, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
+    {
+      _tao_elem = IR::HomeDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          IR::_tc_HomeDef,
+          1,
+          _tao_elem,
+          IR::HomeDef::_tao_any_destructor
+        );
+      return 1;
+    }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = IR::HomeDef::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = IR::HomeDef::_nil ();
+  return 0;
+}
+
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<IR::HomeDef,IR::HomeDef_var>;
+  template class TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<IR::HomeDef,IR::HomeDef_var>
+#  pragma instantiate TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+void operator<<= (CORBA::Any &_tao_any, const IR::HomeDescription &_tao_elem) // copying
+{
+  TAO_OutputCDR stream;
+  stream << _tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_HomeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin ()
+    );
+}
+
+void operator<<= (CORBA::Any &_tao_any, IR::HomeDescription *_tao_elem) // non copying
+{
+  TAO_OutputCDR stream;
+  stream << *_tao_elem;
+  _tao_any._tao_replace (
+      IR::_tc_HomeDescription,
+      TAO_ENCAP_BYTE_ORDER,
+      stream.begin (),
+      1,
+      _tao_elem,
+      IR::HomeDescription::_tao_any_destructor
+    );
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, IR::HomeDescription *&_tao_elem)
+{
+  return _tao_any >>= ACE_const_cast(const IR::HomeDescription*&,_tao_elem);
+}
+
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const IR::HomeDescription *&_tao_elem)
+{
+  _tao_elem = 0;
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (IR::_tc_HomeDescription, ACE_TRY_ENV)) // not equal
       {
-        _tao_elem = 0;
         return 0;
       }
     ACE_TRY_CHECK;
     if (_tao_any.any_owns_data ())
     {
-      _tao_elem = (CORBA::ValueDescription *)_tao_any.value ();
+      _tao_elem = ACE_static_cast(
+          const IR::HomeDescription*,
+          _tao_any.value ()
+        );
       return 1;
     }
     else
     {
-      ACE_NEW_RETURN (_tao_elem, CORBA::ValueDescription, 0);
+      IR::HomeDescription *tmp;
+      ACE_NEW_RETURN (tmp, IR::HomeDescription, 0);
       TAO_InputCDR stream (
           _tao_any._tao_get_cdr (),
           _tao_any._tao_byte_order ()
         );
-      if (stream >> *_tao_elem)
+      if (stream >> *tmp)
       {
         ((CORBA::Any *)&_tao_any)->_tao_replace (
-            CORBA::_tc_ValueDescription,
+            IR::_tc_HomeDescription,
             1,
-            ACE_reinterpret_cast (void *, _tao_elem),
-            CORBA::ValueDescription::_tao_any_destructor
+            ACE_static_cast (void *, tmp),
+            IR::HomeDescription::_tao_any_destructor
           );
+        _tao_elem = tmp;
         return 1;
       }
       else
       {
-        delete _tao_elem;
-        _tao_elem = 0;
+        delete tmp;
       }
     }
   }
   ACE_CATCHANY
   {
-    delete _tao_elem;
-    _tao_elem = 0;
-    return 0;
   }
   ACE_ENDTRY;
   return 0;
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const CORBA::ValueDescription *&_tao_elem)
+CORBA::IRObject_ptr (*_TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, CORBA::IRObject_ptr _tao_elem)
 {
-  return _tao_any >>= ACE_const_cast(CORBA::ValueDescription *&,_tao_elem);
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_IRObject, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::IRObject::_duplicate (_tao_elem),
+        CORBA::IRObject::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer) (
-    CORBA::Object_ptr obj
-  ) = 0;
-void operator<<= (CORBA::Any &_tao_any, CORBA::ValueBoxDef_ptr _tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::IRObject_ptr &_tao_elem)
 {
-    TAO_OutputCDR stream;
-    if (stream << _tao_elem)
+  ACE_TRY_NEW_ENV
+  {
+    _tao_elem = CORBA::IRObject::_nil ();
+    CORBA::TypeCode_var type = _tao_any.type ();
+    if (!type->equivalent (CORBA::_tc_IRObject, ACE_TRY_ENV)) // not equal
+      {
+        return 0;
+      }
+    ACE_TRY_CHECK;
+    TAO_InputCDR stream (
+        _tao_any._tao_get_cdr (),
+        _tao_any._tao_byte_order ()
+      );
+    CORBA::Object_var _tao_obj_var;
+    if (stream >> _tao_obj_var.out ())
     {
-      _tao_any._tao_replace (
-          CORBA::_tc_ValueBoxDef,
-          TAO_ENCAP_BYTE_ORDER,
-          stream.begin ()
+      _tao_elem = CORBA::IRObject::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      ACE_TRY_CHECK;
+      
+      ((CORBA::Any *)&_tao_any)->_tao_replace (
+          CORBA::_tc_IRObject,
+          1,
+          _tao_elem,
+          CORBA::IRObject::_tao_any_destructor
         );
+      return 1;
     }
+  }
+  ACE_CATCHANY
+  {
+    _tao_elem = CORBA::IRObject::_nil ();
+    return 0;
+  }
+  ACE_ENDTRY;
+  _tao_elem = CORBA::IRObject::_nil ();
+  return 0;
 }
 
-void CORBA::ValueBoxDef::_tao_any_destructor (void *x)
+#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
+    defined (ACE_HAS_GNU_REPO)
+    template class TAO_Object_Field_T<CORBA::IRObject,CORBA::IRObject_var>;
+  template class TAO_Object_Manager<CORBA::IRObject,CORBA::IRObject_var>;
+#elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
+#  pragma instantiate TAO_Object_Field_T<CORBA::IRObject,CORBA::IRObject_var>
+#  pragma instantiate TAO_Object_Manager<CORBA::IRObject,CORBA::IRObject_var>
+#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
+
+CORBA::TypeCodeFactory_ptr (*_TAO_collocation_CORBA_TypeCodeFactory_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  ) = 0;
+void operator<<= (CORBA::Any &_tao_any, CORBA::TypeCodeFactory_ptr _tao_elem)
 {
-  CORBA::ValueBoxDef *tmp = ACE_static_cast(CORBA::ValueBoxDef*,x);
-  delete tmp;
+  TAO_OutputCDR stream;
+  if (stream << _tao_elem)
+  {
+    _tao_any._tao_replace (
+        CORBA::_tc_TypeCodeFactory, 
+        TAO_ENCAP_BYTE_ORDER,
+        stream.begin (),
+        1,
+        CORBA::TypeCodeFactory::_duplicate (_tao_elem),
+        CORBA::TypeCodeFactory::_tao_any_destructor
+      );
+  }
 }
 
-CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueBoxDef_ptr &_tao_elem)
+CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::TypeCodeFactory_ptr &_tao_elem)
 {
   ACE_TRY_NEW_ENV
   {
-    _tao_elem = CORBA::ValueBoxDef::_nil ();
+    _tao_elem = CORBA::TypeCodeFactory::_nil ();
     CORBA::TypeCode_var type = _tao_any.type ();
-    if (!type->equivalent (CORBA::_tc_ValueBoxDef, ACE_TRY_ENV)) // not equal
+    if (!type->equivalent (CORBA::_tc_TypeCodeFactory, ACE_TRY_ENV)) // not equal
       {
         return 0;
       }
@@ -18622,39 +46867,40 @@ CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, CORBA::ValueBoxDef_ptr &
     CORBA::Object_var _tao_obj_var;
     if (stream >> _tao_obj_var.out ())
     {
-      _tao_elem = CORBA::ValueBoxDef::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
+      _tao_elem = CORBA::TypeCodeFactory::_narrow (_tao_obj_var.in (), ACE_TRY_ENV);
       ACE_TRY_CHECK;
+      
       ((CORBA::Any *)&_tao_any)->_tao_replace (
-          CORBA::_tc_ValueBoxDef,
+          CORBA::_tc_TypeCodeFactory,
           1,
           _tao_elem,
-          CORBA::ValueBoxDef::_tao_any_destructor
+          CORBA::TypeCodeFactory::_tao_any_destructor
         );
       return 1;
     }
   }
   ACE_CATCHANY
   {
-    _tao_elem = CORBA::ValueBoxDef::_nil ();
+    _tao_elem = CORBA::TypeCodeFactory::_nil ();
     return 0;
   }
   ACE_ENDTRY;
-  _tao_elem = CORBA::ValueBoxDef::_nil ();
+  _tao_elem = CORBA::TypeCodeFactory::_nil ();
   return 0;
 }
 
 #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
     defined (ACE_HAS_GNU_REPO)
-    template class TAO_Object_Field_T<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var>;
-  template class TAO_Object_Manager<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var>;
+    template class TAO_Object_Field_T<CORBA::TypeCodeFactory,CORBA::TypeCodeFactory_var>;
+  template class TAO_Object_Manager<CORBA::TypeCodeFactory,CORBA::TypeCodeFactory_var>;
 #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
-#  pragma instantiate TAO_Object_Field_T<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var>
-#  pragma instantiate TAO_Object_Manager<CORBA::ValueBoxDef,CORBA::ValueBoxDef_var>
+#  pragma instantiate TAO_Object_Field_T<CORBA::TypeCodeFactory,CORBA::TypeCodeFactory_var>
+#  pragma instantiate TAO_Object_Manager<CORBA::TypeCodeFactory,CORBA::TypeCodeFactory_var>
 #endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_InterfaceDefSeq &_tao_sequence
+    const IR::InterfaceDefSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18662,7 +46908,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18670,7 +46918,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_InterfaceDefSeq &_tao_sequence
+    IR::InterfaceDefSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18678,10 +46926,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18689,7 +46942,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ValueDefSeq &_tao_sequence
+    const IR::ValueDefSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18697,7 +46950,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18705,7 +46960,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_ValueDefSeq &_tao_sequence
+    IR::ValueDefSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18713,10 +46968,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18724,7 +46984,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ContainedSeq &_tao_sequence
+    const IR::ComponentDefSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18732,7 +46992,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18740,7 +47002,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_ContainedSeq &_tao_sequence
+    IR::ComponentDefSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18748,10 +47010,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18759,7 +47026,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_StructMemberSeq &_tao_sequence
+    const IR::ProvidesDefSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18767,7 +47034,387 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::ProvidesDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::UsesDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::UsesDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::HomeDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::HomeDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::EmitsDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::EmitsDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::PublishesDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::PublishesDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ConsumesDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::ConsumesDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::FactoryDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::FactoryDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::FinderDefSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::FinderDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ContainedSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::ContainedSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::StructMemberSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18775,7 +47422,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_StructMemberSeq &_tao_sequence
+    IR::StructMemberSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18783,10 +47430,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18794,7 +47446,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_InitializerSeq &_tao_sequence
+    const IR::InitializerSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18802,7 +47454,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18810,7 +47464,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_InitializerSeq &_tao_sequence
+    IR::InitializerSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18818,10 +47472,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18829,7 +47488,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_UnionMemberSeq &_tao_sequence
+    const IR::UnionMemberSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18837,7 +47496,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18845,7 +47506,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_UnionMemberSeq &_tao_sequence
+    IR::UnionMemberSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18853,10 +47514,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18864,7 +47530,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_EnumMemberSeq &_tao_sequence
+    const IR::EnumMemberSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18872,7 +47538,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18880,7 +47548,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_EnumMemberSeq &_tao_sequence
+    IR::EnumMemberSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18888,10 +47556,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18899,7 +47572,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_Container::DescriptionSeq &_tao_sequence
+    const IR::Container::DescriptionSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18907,7 +47580,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18915,7 +47590,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_Container::DescriptionSeq &_tao_sequence
+    IR::Container::DescriptionSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18923,10 +47598,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18934,7 +47614,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ParDescriptionSeq &_tao_sequence
+    const IR::ExceptionDefSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18942,7 +47622,51 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::ExceptionDefSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ExcDescriptionSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18950,7 +47674,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_ParDescriptionSeq &_tao_sequence
+    IR::ExcDescriptionSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18958,10 +47682,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18969,7 +47698,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ContextIdSeq &_tao_sequence
+    const IR::ParDescriptionSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -18977,7 +47706,51 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator>> (
+    TAO_InputCDR &strm,
+    IR::ParDescriptionSeq &_tao_sequence
+  )
+{
+  CORBA::ULong _tao_seq_len;
+  if (strm >> _tao_seq_len)
+  {
+    // set the length of the sequence
+    _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
+    // retrieve all the elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
+    return _tao_marshal_flag;
+  }
+  return 0; // error
+}
+
+CORBA::Boolean operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ContextIdSeq &_tao_sequence
+  )
+{
+  if (strm << _tao_sequence.length ())
+  {
+    // encode all elements
+    CORBA::Boolean _tao_marshal_flag = 1;
+    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -18985,7 +47758,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_ContextIdSeq &_tao_sequence
+    IR::ContextIdSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -18993,10 +47766,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19004,7 +47782,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ExceptionDefSeq &_tao_sequence
+    const IR::RepositoryIdSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -19012,7 +47790,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19020,7 +47800,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_ExceptionDefSeq &_tao_sequence
+    IR::RepositoryIdSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -19028,10 +47808,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19039,7 +47824,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ExcDescriptionSeq &_tao_sequence
+    const IR::OpDescriptionSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -19047,7 +47832,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19055,7 +47842,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_ExcDescriptionSeq &_tao_sequence
+    IR::OpDescriptionSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -19063,10 +47850,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19074,7 +47866,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_RepositoryIdSeq &_tao_sequence
+    const IR::AttrDescriptionSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -19082,7 +47874,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-      _tao_marshal_flag = (strm << _tao_sequence[i].in ());
+    {
+      _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19090,7 +47884,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_RepositoryIdSeq &_tao_sequence
+    IR::AttrDescriptionSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -19098,10 +47892,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
-      _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
+    {
+      _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19109,7 +47908,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_OpDescriptionSeq &_tao_sequence
+    const IR::ValueMemberSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -19117,7 +47916,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19125,7 +47926,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_OpDescriptionSeq &_tao_sequence
+    IR::ValueMemberSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -19133,10 +47934,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19144,7 +47950,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_AttrDescriptionSeq &_tao_sequence
+    const IR::ProvidesDescSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -19152,7 +47958,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19160,7 +47968,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_AttrDescriptionSeq &_tao_sequence
+    IR::ProvidesDescSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -19168,10 +47976,15 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19179,7 +47992,7 @@ CORBA::Boolean operator>> (
 
 CORBA::Boolean operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ValueMemberSeq &_tao_sequence
+    const IR::UsesDescSeq &_tao_sequence
   )
 {
   if (strm << _tao_sequence.length ())
@@ -19187,7 +48000,9 @@ CORBA::Boolean operator<< (
     // encode all elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm << _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
@@ -19195,7 +48010,7 @@ CORBA::Boolean operator<< (
 
 CORBA::Boolean operator>> (
     TAO_InputCDR &strm,
-    CORBA_ValueMemberSeq &_tao_sequence
+    IR::UsesDescSeq &_tao_sequence
   )
 {
   CORBA::ULong _tao_seq_len;
@@ -19203,14 +48018,18 @@ CORBA::Boolean operator>> (
   {
     // set the length of the sequence
     _tao_sequence.length (_tao_seq_len);
+    // If length is 0 we return true.
+    if (0 >= _tao_seq_len) 
+      return 1;
     // retrieve all the elements
     CORBA::Boolean _tao_marshal_flag = 1;
     for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
+    {
       _tao_marshal_flag = (strm >> _tao_sequence[i]);
+    }
     return _tao_marshal_flag;
   }
   return 0; // error
 }
 
-
 #endif /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
diff --git a/TAO/tao/InterfaceC.h b/TAO/tao/InterfaceC.h
index 3807acee33f..d0c32801ef7 100644
--- a/TAO/tao/InterfaceC.h
+++ b/TAO/tao/InterfaceC.h
@@ -14,27 +14,28 @@
 
 #include "tao/corbafwd.h"
 #include "tao/Object.h"
-
 #include "tao/Any.h"
 #include "tao/Sequence_T.h"
 #include "tao/varout.h"
 
 #if (TAO_HAS_INTERFACE_REPOSITORY == 1)
+
 #if !defined (ACE_LACKS_PRAGMA_ONCE)
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
-
 #if defined (TAO_EXPORT_MACRO)
 #undef TAO_EXPORT_MACRO
 #endif
-#define TAO_EXPORT_MACRO
+#define TAO_EXPORT_MACRO TAO_Export
+
 #if defined (TAO_EXPORT_NESTED_CLASSES)
 #  if defined (TAO_EXPORT_NESTED_MACRO)
 #    undef TAO_EXPORT_NESTED_MACRO
 #  endif /* defined (TAO_EXPORT_NESTED_MACRO) */
-#  define TAO_EXPORT_NESTED_MACRO
+#  define TAO_EXPORT_NESTED_MACRO TAO_Export
 #endif /* TAO_EXPORT_NESTED_CLASSES */
+
 #if defined(_MSC_VER)
 #if (_MSC_VER >= 1200)
 #pragma warning(push)
@@ -42,6 +43,32 @@
 #pragma warning(disable:4250)
 #endif /* _MSC_VER */
 
+TAO_NAMESPACE  IR
+{
+  typedef char * Identifier;
+  typedef CORBA::String_var Identifier_var;
+  typedef CORBA::String_out Identifier_out;
+    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Identifier;
+
+  typedef char * ScopedName;
+  typedef CORBA::String_var ScopedName_var;
+  typedef CORBA::String_out ScopedName_out;
+    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ScopedName;
+
+  typedef char * RepositoryId;
+  typedef CORBA::String_var RepositoryId_var;
+  typedef CORBA::String_out RepositoryId_out;
+    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RepositoryId;
+
+  typedef IR_DefinitionKind DefinitionKind;
+  typedef DefinitionKind &DefinitionKind_out;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_DefinitionKind;
+
+  typedef char * VersionSpec;
+  typedef CORBA::String_var VersionSpec_var;
+  typedef CORBA::String_out VersionSpec_out;
+    TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_VersionSpec;
+
   class TAO_Export CORBA_IRObject_var
   {
   public:
@@ -124,7 +151,7 @@ class TAO_Export CORBA_IRObject : public virtual ACE_CORBA_1 (Object)
       }
     static void _tao_any_destructor (void*);
 
-    virtual CORBA::DefinitionKind def_kind (
+    virtual IR::DefinitionKind def_kind (
         CORBA::Environment &ACE_TRY_ENV =
           TAO_default_environment ()
       )
@@ -163,259 +190,299 @@ class TAO_Export CORBA_IRObject : public virtual ACE_CORBA_1 (Object)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINED___VAR_CH_)
-#define _CORBA_CONTAINED___VAR_CH_
+  class Contained;
+  
+#if !defined (_IR_CONTAINED___PTR_CH_)
+#define _IR_CONTAINED___PTR_CH_
 
-  class TAO_Export CORBA_Contained_var
-  {
-  public:
-    CORBA_Contained_var (void); // default constructor
-    CORBA_Contained_var (CORBA_Contained_ptr);
-    CORBA_Contained_var (const CORBA_Contained_var &); // copy constructor
-    ~CORBA_Contained_var (void); // destructor
+typedef Contained *Contained_ptr;
 
-    CORBA_Contained_var &operator= (CORBA_Contained_ptr);
-    CORBA_Contained_var &operator= (const CORBA_Contained_var &);
-    CORBA_Contained_ptr operator-> (void) const;
+#endif /* end #if !defined */
 
-    operator const CORBA_Contained_ptr &() const;
-    operator CORBA_Contained_ptr &();
-    // in, inout, out, _retn
-    CORBA_Contained_ptr in (void) const;
-    CORBA_Contained_ptr &inout (void);
-    CORBA_Contained_ptr &out (void);
-    CORBA_Contained_ptr _retn (void);
-    CORBA_Contained_ptr ptr (void) const;
+
+#if !defined (_IR_CONTAINED___VAR_CH_)
+#define _IR_CONTAINED___VAR_CH_
+
+  class TAO_Export Contained_var
+  {
+  public:
+    Contained_var (void); // default constructor
+    Contained_var (Contained_ptr);
+    Contained_var (const Contained_var &); // copy constructor
+    ~Contained_var (void); // destructor
+    
+    Contained_var &operator= (Contained_ptr);
+    Contained_var &operator= (const Contained_var &);
+    Contained_ptr operator-> (void) const;
+    
+    operator const Contained_ptr &() const;
+    operator Contained_ptr &();
+    // in, inout, out, _retn 
+    Contained_ptr in (void) const;
+    Contained_ptr &inout (void);
+    Contained_ptr &out (void);
+    Contained_ptr _retn (void);
+    Contained_ptr ptr (void) const;
 
   private:
-    CORBA_Contained_ptr ptr_;
+    Contained_ptr ptr_;
   };
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINED___OUT_CH_)
-#define _CORBA_CONTAINED___OUT_CH_
+#if !defined (_IR_CONTAINED___OUT_CH_)
+#define _IR_CONTAINED___OUT_CH_
 
-  class TAO_Export CORBA_Contained_out
+  class TAO_Export Contained_out
   {
   public:
-    CORBA_Contained_out (CORBA_Contained_ptr &);
-    CORBA_Contained_out (CORBA_Contained_var &);
-    CORBA_Contained_out (const CORBA_Contained_out &);
-    CORBA_Contained_out &operator= (const CORBA_Contained_out &);
-    CORBA_Contained_out &operator= (const CORBA_Contained_var &);
-    CORBA_Contained_out &operator= (CORBA_Contained_ptr);
-    operator CORBA_Contained_ptr &();
-    CORBA_Contained_ptr &ptr (void);
-    CORBA_Contained_ptr operator-> (void);
-
+    Contained_out (Contained_ptr &);
+    Contained_out (Contained_var &);
+    Contained_out (const Contained_out &);
+    Contained_out &operator= (const Contained_out &);
+    Contained_out &operator= (const Contained_var &);
+    Contained_out &operator= (Contained_ptr);
+    operator Contained_ptr &();
+    Contained_ptr &ptr (void);
+    Contained_ptr operator-> (void);
+    
   private:
-    CORBA_Contained_ptr &ptr_;
+    Contained_ptr &ptr_;
   };
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_REPOSITORY___VAR_CH_)
-#define _CORBA_REPOSITORY___VAR_CH_
+  class Repository;
+  
+#if !defined (_IR_REPOSITORY___PTR_CH_)
+#define _IR_REPOSITORY___PTR_CH_
 
-  class TAO_Export CORBA_Repository_var
-  {
-  public:
-    CORBA_Repository_var (void); // default constructor
-    CORBA_Repository_var (CORBA_Repository_ptr);
-    CORBA_Repository_var (const CORBA_Repository_var &); // copy constructor
-    ~CORBA_Repository_var (void); // destructor
+typedef Repository *Repository_ptr;
+
+#endif /* end #if !defined */
 
-    CORBA_Repository_var &operator= (CORBA_Repository_ptr);
-    CORBA_Repository_var &operator= (const CORBA_Repository_var &);
-    CORBA_Repository_ptr operator-> (void) const;
 
-    operator const CORBA_Repository_ptr &() const;
-    operator CORBA_Repository_ptr &();
-    // in, inout, out, _retn
-    CORBA_Repository_ptr in (void) const;
-    CORBA_Repository_ptr &inout (void);
-    CORBA_Repository_ptr &out (void);
-    CORBA_Repository_ptr _retn (void);
-    CORBA_Repository_ptr ptr (void) const;
+#if !defined (_IR_REPOSITORY___VAR_CH_)
+#define _IR_REPOSITORY___VAR_CH_
+
+  class TAO_Export Repository_var
+  {
+  public:
+    Repository_var (void); // default constructor
+    Repository_var (Repository_ptr);
+    Repository_var (const Repository_var &); // copy constructor
+    ~Repository_var (void); // destructor
+    
+    Repository_var &operator= (Repository_ptr);
+    Repository_var &operator= (const Repository_var &);
+    Repository_ptr operator-> (void) const;
+    
+    operator const Repository_ptr &() const;
+    operator Repository_ptr &();
+    // in, inout, out, _retn 
+    Repository_ptr in (void) const;
+    Repository_ptr &inout (void);
+    Repository_ptr &out (void);
+    Repository_ptr _retn (void);
+    Repository_ptr ptr (void) const;
 
   private:
-    CORBA_Repository_ptr ptr_;
+    Repository_ptr ptr_;
   };
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_REPOSITORY___OUT_CH_)
-#define _CORBA_REPOSITORY___OUT_CH_
+#if !defined (_IR_REPOSITORY___OUT_CH_)
+#define _IR_REPOSITORY___OUT_CH_
 
-  class TAO_Export CORBA_Repository_out
+  class TAO_Export Repository_out
   {
   public:
-    CORBA_Repository_out (CORBA_Repository_ptr &);
-    CORBA_Repository_out (CORBA_Repository_var &);
-    CORBA_Repository_out (const CORBA_Repository_out &);
-    CORBA_Repository_out &operator= (const CORBA_Repository_out &);
-    CORBA_Repository_out &operator= (const CORBA_Repository_var &);
-    CORBA_Repository_out &operator= (CORBA_Repository_ptr);
-    operator CORBA_Repository_ptr &();
-    CORBA_Repository_ptr &ptr (void);
-    CORBA_Repository_ptr operator-> (void);
-
+    Repository_out (Repository_ptr &);
+    Repository_out (Repository_var &);
+    Repository_out (const Repository_out &);
+    Repository_out &operator= (const Repository_out &);
+    Repository_out &operator= (const Repository_var &);
+    Repository_out &operator= (Repository_ptr);
+    operator Repository_ptr &();
+    Repository_ptr &ptr (void);
+    Repository_ptr operator-> (void);
+    
   private:
-    CORBA_Repository_ptr &ptr_;
+    Repository_ptr &ptr_;
   };
 
 
 #endif /* end #if !defined */
 
+  class Container;
+  
+#if !defined (_IR_CONTAINER___PTR_CH_)
+#define _IR_CONTAINER___PTR_CH_
 
-#if !defined (_CORBA_CONTAINER___VAR_CH_)
-#define _CORBA_CONTAINER___VAR_CH_
+typedef Container *Container_ptr;
 
-  class TAO_Export CORBA_Container_var
-  {
-  public:
-    CORBA_Container_var (void); // default constructor
-    CORBA_Container_var (CORBA_Container_ptr);
-    CORBA_Container_var (const CORBA_Container_var &); // copy constructor
-    ~CORBA_Container_var (void); // destructor
+#endif /* end #if !defined */
 
-    CORBA_Container_var &operator= (CORBA_Container_ptr);
-    CORBA_Container_var &operator= (const CORBA_Container_var &);
-    CORBA_Container_ptr operator-> (void) const;
 
-    operator const CORBA_Container_ptr &() const;
-    operator CORBA_Container_ptr &();
-    // in, inout, out, _retn
-    CORBA_Container_ptr in (void) const;
-    CORBA_Container_ptr &inout (void);
-    CORBA_Container_ptr &out (void);
-    CORBA_Container_ptr _retn (void);
-    CORBA_Container_ptr ptr (void) const;
+#if !defined (_IR_CONTAINER___VAR_CH_)
+#define _IR_CONTAINER___VAR_CH_
+
+  class TAO_Export Container_var
+  {
+  public:
+    Container_var (void); // default constructor
+    Container_var (Container_ptr);
+    Container_var (const Container_var &); // copy constructor
+    ~Container_var (void); // destructor
+    
+    Container_var &operator= (Container_ptr);
+    Container_var &operator= (const Container_var &);
+    Container_ptr operator-> (void) const;
+    
+    operator const Container_ptr &() const;
+    operator Container_ptr &();
+    // in, inout, out, _retn 
+    Container_ptr in (void) const;
+    Container_ptr &inout (void);
+    Container_ptr &out (void);
+    Container_ptr _retn (void);
+    Container_ptr ptr (void) const;
 
   private:
-    CORBA_Container_ptr ptr_;
+    Container_ptr ptr_;
   };
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINER___OUT_CH_)
-#define _CORBA_CONTAINER___OUT_CH_
+#if !defined (_IR_CONTAINER___OUT_CH_)
+#define _IR_CONTAINER___OUT_CH_
 
-  class TAO_Export CORBA_Container_out
+  class TAO_Export Container_out
   {
   public:
-    CORBA_Container_out (CORBA_Container_ptr &);
-    CORBA_Container_out (CORBA_Container_var &);
-    CORBA_Container_out (const CORBA_Container_out &);
-    CORBA_Container_out &operator= (const CORBA_Container_out &);
-    CORBA_Container_out &operator= (const CORBA_Container_var &);
-    CORBA_Container_out &operator= (CORBA_Container_ptr);
-    operator CORBA_Container_ptr &();
-    CORBA_Container_ptr &ptr (void);
-    CORBA_Container_ptr operator-> (void);
-
+    Container_out (Container_ptr &);
+    Container_out (Container_var &);
+    Container_out (const Container_out &);
+    Container_out &operator= (const Container_out &);
+    Container_out &operator= (const Container_var &);
+    Container_out &operator= (Container_ptr);
+    operator Container_ptr &();
+    Container_ptr &ptr (void);
+    Container_ptr operator-> (void);
+    
   private:
-    CORBA_Container_ptr &ptr_;
+    Container_ptr &ptr_;
   };
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_CONTAINED___VAR_CH_)
-#define _CORBA_CONTAINED___VAR_CH_
 
-  class TAO_Export CORBA_Contained_var
-  {
-  public:
-    CORBA_Contained_var (void); // default constructor
-    CORBA_Contained_var (CORBA_Contained_ptr);
-    CORBA_Contained_var (const CORBA_Contained_var &); // copy constructor
-    ~CORBA_Contained_var (void); // destructor
+#if !defined (_IR_CONTAINED___PTR_CH_)
+#define _IR_CONTAINED___PTR_CH_
+
+  class Contained;
+  typedef Contained *Contained_ptr;
+  
+#endif /* end #if !defined */
 
-    CORBA_Contained_var &operator= (CORBA_Contained_ptr);
-    CORBA_Contained_var &operator= (const CORBA_Contained_var &);
-    CORBA_Contained_ptr operator-> (void) const;
 
-    operator const CORBA_Contained_ptr &() const;
-    operator CORBA_Contained_ptr &();
-    // in, inout, out, _retn
-    CORBA_Contained_ptr in (void) const;
-    CORBA_Contained_ptr &inout (void);
-    CORBA_Contained_ptr &out (void);
-    CORBA_Contained_ptr _retn (void);
-    CORBA_Contained_ptr ptr (void) const;
+#if !defined (_IR_CONTAINED___VAR_CH_)
+#define _IR_CONTAINED___VAR_CH_
+
+  class TAO_Export Contained_var
+  {
+  public:
+    Contained_var (void); // default constructor
+    Contained_var (Contained_ptr);
+    Contained_var (const Contained_var &); // copy constructor
+    ~Contained_var (void); // destructor
+    
+    Contained_var &operator= (Contained_ptr);
+    Contained_var &operator= (const Contained_var &);
+    Contained_ptr operator-> (void) const;
+    
+    operator const Contained_ptr &() const;
+    operator Contained_ptr &();
+    // in, inout, out, _retn 
+    Contained_ptr in (void) const;
+    Contained_ptr &inout (void);
+    Contained_ptr &out (void);
+    Contained_ptr _retn (void);
+    Contained_ptr ptr (void) const;
 
   private:
-    CORBA_Contained_ptr ptr_;
+    Contained_ptr ptr_;
   };
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINED___OUT_CH_)
-#define _CORBA_CONTAINED___OUT_CH_
+#if !defined (_IR_CONTAINED___OUT_CH_)
+#define _IR_CONTAINED___OUT_CH_
 
-  class TAO_Export CORBA_Contained_out
+  class TAO_Export Contained_out
   {
   public:
-    CORBA_Contained_out (CORBA_Contained_ptr &);
-    CORBA_Contained_out (CORBA_Contained_var &);
-    CORBA_Contained_out (const CORBA_Contained_out &);
-    CORBA_Contained_out &operator= (const CORBA_Contained_out &);
-    CORBA_Contained_out &operator= (const CORBA_Contained_var &);
-    CORBA_Contained_out &operator= (CORBA_Contained_ptr);
-    operator CORBA_Contained_ptr &();
-    CORBA_Contained_ptr &ptr (void);
-    CORBA_Contained_ptr operator-> (void);
-
+    Contained_out (Contained_ptr &);
+    Contained_out (Contained_var &);
+    Contained_out (const Contained_out &);
+    Contained_out &operator= (const Contained_out &);
+    Contained_out &operator= (const Contained_var &);
+    Contained_out &operator= (Contained_ptr);
+    operator Contained_ptr &();
+    Contained_ptr &ptr (void);
+    Contained_ptr operator-> (void);
+    
   private:
-    CORBA_Contained_ptr &ptr_;
+    Contained_ptr &ptr_;
   };
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINED_CH_)
-#define _CORBA_CONTAINED_CH_
+#if !defined (_IR_CONTAINED_CH_)
+#define _IR_CONTAINED_CH_
 
-class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
+class TAO_Export Contained: public virtual CORBA_IRObject
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_Contained_ptr _ptr_type;
-    typedef CORBA_Contained_var _var_type;
-  #endif /* __GNUC__ */
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef Contained_ptr _ptr_type;
+    typedef Contained_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
 
     // the static operations
-    static CORBA_Contained_ptr _duplicate (CORBA_Contained_ptr obj);
-    static CORBA_Contained_ptr _narrow (
+    static Contained_ptr _duplicate (Contained_ptr obj);
+    static Contained_ptr _narrow (
         CORBA::Object_ptr obj,
-        CORBA::Environment &env =
+        CORBA::Environment &env = 
           TAO_default_environment ()
       );
-    static CORBA_Contained_ptr _unchecked_narrow (
+    static Contained_ptr _unchecked_narrow (
         CORBA::Object_ptr obj,
-        CORBA::Environment &env =
+        CORBA::Environment &env = 
           TAO_default_environment ()
       );
-    static CORBA_Contained_ptr _nil (void)
+    static Contained_ptr _nil (void)
       {
-        return (CORBA::Contained_ptr)0;
+        return (Contained_ptr)0;
       }
+
     static void _tao_any_destructor (void*);
 
     virtual char * id (
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
@@ -424,7 +491,7 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
 
     virtual void id (
         const char * id,
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
@@ -432,7 +499,7 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
       ));
 
     virtual char * name (
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
@@ -441,7 +508,7 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
 
     virtual void name (
         const char * name,
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
@@ -449,7 +516,7 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
       ));
 
     virtual char * version (
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
@@ -458,15 +525,15 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
 
     virtual void version (
         const char * version,
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA_Container_ptr defined_in (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual IR::Container_ptr defined_in (
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
@@ -474,46 +541,56 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
       ));
 
     virtual char * absolute_name (
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA_Repository_ptr containing_repository (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual IR::Repository_ptr containing_repository (
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    struct  Description
+    struct Description;
+    class Description_var;
+    
+    struct TAO_Export Description
     {
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+      typedef Description_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
       static void _tao_any_destructor (void*);
 
-      CORBA::DefinitionKind kind;
+      ACE_NESTED_CLASS (IR, DefinitionKind) kind;
       CORBA::Any value;
     };
 
-    class Description_var
+    class TAO_Export Description_var
     {
     public:
       Description_var (void); // default constructor
       Description_var (Description *);
       Description_var (const Description_var &); // copy constructor
       ~Description_var (void); // destructor
-
+      
       Description_var &operator= (Description *);
       Description_var &operator= (const Description_var &);
       Description *operator-> (void);
       const Description *operator-> (void) const;
-
+      
       operator const Description &() const;
       operator Description &();
       operator Description &() const;
-      // in, inout, out, _retn
+      operator Description *&(); // variable-size types only
+      
+      // in, inout, out, _retn 
       const Description &in (void) const;
       Description &inout (void);
       Description *&out (void);
@@ -524,7 +601,7 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
       Description *ptr_;
     };
 
-    class  Description_out
+    class TAO_Export Description_out
     {
     public:
       Description_out (Description *&);
@@ -535,7 +612,7 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
       operator Description *&();
       Description *&ptr (void);
       Description *operator-> (void);
-
+      
     private:
       Description *&ptr_;
       // assignment from T_var not allowed
@@ -544,8 +621,8 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
 
     static CORBA::TypeCode_ptr _tc_Description;
 
-    virtual Description * describe (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual IR::Contained::Description * describe (
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
@@ -553,10 +630,10 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
       ));
 
     virtual void move (
-        CORBA_Container_ptr new_container,
+        IR::Container_ptr new_container,
         const char * new_name,
         const char * new_version,
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
@@ -564,7301 +641,16901 @@ class TAO_Export CORBA_Contained: public virtual CORBA_IRObject
       ));
 
     virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
+        const CORBA::Char *type_id, 
+        CORBA::Environment &env = 
           TAO_default_environment ()
       );
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    CORBA_Contained (void);
-    CORBA_Contained (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
+    Contained (void);
+    Contained (TAO_Stub *objref, 
+        TAO_ServantBase *_tao_servant = 0, 
         CORBA::Boolean _tao_collocated = 0
       );
-    virtual ~CORBA_Contained (void);
+    virtual ~Contained (void);
   private:
-    CORBA_Contained (const CORBA_Contained &);
-    void operator= (const CORBA_Contained &);
+    Contained (const Contained &);
+    void operator= (const Contained &);
+};
+
+class TAO_IR_Contained_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_Contained_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_Contained_Default_Proxy_Factory (void);
+  
+  virtual Contained_ptr create_proxy (
+      Contained_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_Contained_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_Contained_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_Contained_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  Contained_ptr create_proxy (
+      Contained_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_Contained_Proxy_Factory_Adapter (void);
+  ~TAO_IR_Contained_Proxy_Factory_Adapter (void);
+  TAO_IR_Contained_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_Contained_Proxy_Factory_Adapter &
+    );
+  TAO_IR_Contained_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
+  typedef ACE_Singleton<TAO_IR_Contained_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_Contained_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_Contained_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, Contained)
+  {
+  public:
+    TAO_IR_Contained_Smart_Proxy_Base (::IR::Contained_ptr proxy);
+    ~TAO_IR_Contained_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual char * id (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void id (
+      const char * id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual char * name (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void name (
+      const char * name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual char * version (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void version (
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::Container_ptr defined_in (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual char * absolute_name (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::Repository_ptr containing_repository (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::Contained::Description * describe (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void move (
+      IR::Container_ptr new_container,
+      const char * new_name,
+      const char * new_version,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::Contained_var base_proxy_;
+};
+
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_MODULEDEF___VAR_CH_)
-#define _CORBA_MODULEDEF___VAR_CH_
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Contained;
 
-  class TAO_Export CORBA_ModuleDef_var
-  {
-  public:
-    CORBA_ModuleDef_var (void); // default constructor
-    CORBA_ModuleDef_var (CORBA_ModuleDef_ptr);
-    CORBA_ModuleDef_var (const CORBA_ModuleDef_var &); // copy constructor
-    ~CORBA_ModuleDef_var (void); // destructor
+class ModuleDef;
 
-    CORBA_ModuleDef_var &operator= (CORBA_ModuleDef_ptr);
-    CORBA_ModuleDef_var &operator= (const CORBA_ModuleDef_var &);
-    CORBA_ModuleDef_ptr operator-> (void) const;
+#if !defined (_IR_MODULEDEF___PTR_CH_)
+#define _IR_MODULEDEF___PTR_CH_
 
-    operator const CORBA_ModuleDef_ptr &() const;
-    operator CORBA_ModuleDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ModuleDef_ptr in (void) const;
-    CORBA_ModuleDef_ptr &inout (void);
-    CORBA_ModuleDef_ptr &out (void);
-    CORBA_ModuleDef_ptr _retn (void);
-    CORBA_ModuleDef_ptr ptr (void) const;
+typedef ModuleDef *ModuleDef_ptr;
 
-  private:
-    CORBA_ModuleDef_ptr ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_MODULEDEF___VAR_CH_)
+#define _IR_MODULEDEF___VAR_CH_
+
+class TAO_Export ModuleDef_var
+{
+public:
+  ModuleDef_var (void); // default constructor
+  ModuleDef_var (ModuleDef_ptr);
+  ModuleDef_var (const ModuleDef_var &); // copy constructor
+  ~ModuleDef_var (void); // destructor
+  
+  ModuleDef_var &operator= (ModuleDef_ptr);
+  ModuleDef_var &operator= (const ModuleDef_var &);
+  ModuleDef_ptr operator-> (void) const;
+  
+  operator const ModuleDef_ptr &() const;
+  operator ModuleDef_ptr &();
+  // in, inout, out, _retn 
+  ModuleDef_ptr in (void) const;
+  ModuleDef_ptr &inout (void);
+  ModuleDef_ptr &out (void);
+  ModuleDef_ptr _retn (void);
+  ModuleDef_ptr ptr (void) const;
+
+private:
+  ModuleDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_MODULEDEF___OUT_CH_)
-#define _CORBA_MODULEDEF___OUT_CH_
+#if !defined (_IR_MODULEDEF___OUT_CH_)
+#define _IR_MODULEDEF___OUT_CH_
 
-  class TAO_Export CORBA_ModuleDef_out
-  {
-  public:
-    CORBA_ModuleDef_out (CORBA_ModuleDef_ptr &);
-    CORBA_ModuleDef_out (CORBA_ModuleDef_var &);
-    CORBA_ModuleDef_out (const CORBA_ModuleDef_out &);
-    CORBA_ModuleDef_out &operator= (const CORBA_ModuleDef_out &);
-    CORBA_ModuleDef_out &operator= (const CORBA_ModuleDef_var &);
-    CORBA_ModuleDef_out &operator= (CORBA_ModuleDef_ptr);
-    operator CORBA_ModuleDef_ptr &();
-    CORBA_ModuleDef_ptr &ptr (void);
-    CORBA_ModuleDef_ptr operator-> (void);
+class TAO_Export ModuleDef_out
+{
+public:
+  ModuleDef_out (ModuleDef_ptr &);
+  ModuleDef_out (ModuleDef_var &);
+  ModuleDef_out (const ModuleDef_out &);
+  ModuleDef_out &operator= (const ModuleDef_out &);
+  ModuleDef_out &operator= (const ModuleDef_var &);
+  ModuleDef_out &operator= (ModuleDef_ptr);
+  operator ModuleDef_ptr &();
+  ModuleDef_ptr &ptr (void);
+  ModuleDef_ptr operator-> (void);
+  
+private:
+  ModuleDef_ptr &ptr_;
+};
 
-  private:
-    CORBA_ModuleDef_ptr &ptr_;
-  };
 
+#endif /* end #if !defined */
+
+class ConstantDef;
+
+#if !defined (_IR_CONSTANTDEF___PTR_CH_)
+#define _IR_CONSTANTDEF___PTR_CH_
+
+typedef ConstantDef *ConstantDef_ptr;
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_CONSTANTDEF___VAR_CH_)
-#define _CORBA_CONSTANTDEF___VAR_CH_
 
-  class TAO_Export CORBA_ConstantDef_var
-  {
-  public:
-    CORBA_ConstantDef_var (void); // default constructor
-    CORBA_ConstantDef_var (CORBA_ConstantDef_ptr);
-    CORBA_ConstantDef_var (const CORBA_ConstantDef_var &); // copy constructor
-    ~CORBA_ConstantDef_var (void); // destructor
+#if !defined (_IR_CONSTANTDEF___VAR_CH_)
+#define _IR_CONSTANTDEF___VAR_CH_
+
+class TAO_Export ConstantDef_var
+{
+public:
+  ConstantDef_var (void); // default constructor
+  ConstantDef_var (ConstantDef_ptr);
+  ConstantDef_var (const ConstantDef_var &); // copy constructor
+  ~ConstantDef_var (void); // destructor
+  
+  ConstantDef_var &operator= (ConstantDef_ptr);
+  ConstantDef_var &operator= (const ConstantDef_var &);
+  ConstantDef_ptr operator-> (void) const;
+  
+  operator const ConstantDef_ptr &() const;
+  operator ConstantDef_ptr &();
+  // in, inout, out, _retn 
+  ConstantDef_ptr in (void) const;
+  ConstantDef_ptr &inout (void);
+  ConstantDef_ptr &out (void);
+  ConstantDef_ptr _retn (void);
+  ConstantDef_ptr ptr (void) const;
+
+private:
+  ConstantDef_ptr ptr_;
+};
 
-    CORBA_ConstantDef_var &operator= (CORBA_ConstantDef_ptr);
-    CORBA_ConstantDef_var &operator= (const CORBA_ConstantDef_var &);
-    CORBA_ConstantDef_ptr operator-> (void) const;
 
-    operator const CORBA_ConstantDef_ptr &() const;
-    operator CORBA_ConstantDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ConstantDef_ptr in (void) const;
-    CORBA_ConstantDef_ptr &inout (void);
-    CORBA_ConstantDef_ptr &out (void);
-    CORBA_ConstantDef_ptr _retn (void);
-    CORBA_ConstantDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_ConstantDef_ptr ptr_;
-  };
+
+#if !defined (_IR_CONSTANTDEF___OUT_CH_)
+#define _IR_CONSTANTDEF___OUT_CH_
+
+class TAO_Export ConstantDef_out
+{
+public:
+  ConstantDef_out (ConstantDef_ptr &);
+  ConstantDef_out (ConstantDef_var &);
+  ConstantDef_out (const ConstantDef_out &);
+  ConstantDef_out &operator= (const ConstantDef_out &);
+  ConstantDef_out &operator= (const ConstantDef_var &);
+  ConstantDef_out &operator= (ConstantDef_ptr);
+  operator ConstantDef_ptr &();
+  ConstantDef_ptr &ptr (void);
+  ConstantDef_ptr operator-> (void);
+  
+private:
+  ConstantDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
+class IDLType;
 
-#if !defined (_CORBA_CONSTANTDEF___OUT_CH_)
-#define _CORBA_CONSTANTDEF___OUT_CH_
+#if !defined (_IR_IDLTYPE___PTR_CH_)
+#define _IR_IDLTYPE___PTR_CH_
 
-  class TAO_Export CORBA_ConstantDef_out
-  {
-  public:
-    CORBA_ConstantDef_out (CORBA_ConstantDef_ptr &);
-    CORBA_ConstantDef_out (CORBA_ConstantDef_var &);
-    CORBA_ConstantDef_out (const CORBA_ConstantDef_out &);
-    CORBA_ConstantDef_out &operator= (const CORBA_ConstantDef_out &);
-    CORBA_ConstantDef_out &operator= (const CORBA_ConstantDef_var &);
-    CORBA_ConstantDef_out &operator= (CORBA_ConstantDef_ptr);
-    operator CORBA_ConstantDef_ptr &();
-    CORBA_ConstantDef_ptr &ptr (void);
-    CORBA_ConstantDef_ptr operator-> (void);
+typedef IDLType *IDLType_ptr;
 
-  private:
-    CORBA_ConstantDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_IDLTYPE___VAR_CH_)
+#define _IR_IDLTYPE___VAR_CH_
+
+class TAO_Export IDLType_var
+{
+public:
+  IDLType_var (void); // default constructor
+  IDLType_var (IDLType_ptr);
+  IDLType_var (const IDLType_var &); // copy constructor
+  ~IDLType_var (void); // destructor
+  
+  IDLType_var &operator= (IDLType_ptr);
+  IDLType_var &operator= (const IDLType_var &);
+  IDLType_ptr operator-> (void) const;
+  
+  operator const IDLType_ptr &() const;
+  operator IDLType_ptr &();
+  // in, inout, out, _retn 
+  IDLType_ptr in (void) const;
+  IDLType_ptr &inout (void);
+  IDLType_ptr &out (void);
+  IDLType_ptr _retn (void);
+  IDLType_ptr ptr (void) const;
+
+private:
+  IDLType_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_IDLTYPE___VAR_CH_)
-#define _CORBA_IDLTYPE___VAR_CH_
 
-  class TAO_Export CORBA_IDLType_var
-  {
-  public:
-    CORBA_IDLType_var (void); // default constructor
-    CORBA_IDLType_var (CORBA_IDLType_ptr);
-    CORBA_IDLType_var (const CORBA_IDLType_var &); // copy constructor
-    ~CORBA_IDLType_var (void); // destructor
+#if !defined (_IR_IDLTYPE___OUT_CH_)
+#define _IR_IDLTYPE___OUT_CH_
 
-    CORBA_IDLType_var &operator= (CORBA_IDLType_ptr);
-    CORBA_IDLType_var &operator= (const CORBA_IDLType_var &);
-    CORBA_IDLType_ptr operator-> (void) const;
+class TAO_Export IDLType_out
+{
+public:
+  IDLType_out (IDLType_ptr &);
+  IDLType_out (IDLType_var &);
+  IDLType_out (const IDLType_out &);
+  IDLType_out &operator= (const IDLType_out &);
+  IDLType_out &operator= (const IDLType_var &);
+  IDLType_out &operator= (IDLType_ptr);
+  operator IDLType_ptr &();
+  IDLType_ptr &ptr (void);
+  IDLType_ptr operator-> (void);
+  
+private:
+  IDLType_ptr &ptr_;
+};
 
-    operator const CORBA_IDLType_ptr &() const;
-    operator CORBA_IDLType_ptr &();
-    // in, inout, out, _retn
-    CORBA_IDLType_ptr in (void) const;
-    CORBA_IDLType_ptr &inout (void);
-    CORBA_IDLType_ptr &out (void);
-    CORBA_IDLType_ptr _retn (void);
-    CORBA_IDLType_ptr ptr (void) const;
 
-  private:
-    CORBA_IDLType_ptr ptr_;
-  };
+#endif /* end #if !defined */
+
+class StructDef;
+
+#if !defined (_IR_STRUCTDEF___PTR_CH_)
+#define _IR_STRUCTDEF___PTR_CH_
 
+typedef StructDef *StructDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_IDLTYPE___OUT_CH_)
-#define _CORBA_IDLTYPE___OUT_CH_
+#if !defined (_IR_STRUCTDEF___VAR_CH_)
+#define _IR_STRUCTDEF___VAR_CH_
+
+class TAO_Export StructDef_var
+{
+public:
+  StructDef_var (void); // default constructor
+  StructDef_var (StructDef_ptr);
+  StructDef_var (const StructDef_var &); // copy constructor
+  ~StructDef_var (void); // destructor
+  
+  StructDef_var &operator= (StructDef_ptr);
+  StructDef_var &operator= (const StructDef_var &);
+  StructDef_ptr operator-> (void) const;
+  
+  operator const StructDef_ptr &() const;
+  operator StructDef_ptr &();
+  // in, inout, out, _retn 
+  StructDef_ptr in (void) const;
+  StructDef_ptr &inout (void);
+  StructDef_ptr &out (void);
+  StructDef_ptr _retn (void);
+  StructDef_ptr ptr (void) const;
+
+private:
+  StructDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_IDLType_out
-  {
-  public:
-    CORBA_IDLType_out (CORBA_IDLType_ptr &);
-    CORBA_IDLType_out (CORBA_IDLType_var &);
-    CORBA_IDLType_out (const CORBA_IDLType_out &);
-    CORBA_IDLType_out &operator= (const CORBA_IDLType_out &);
-    CORBA_IDLType_out &operator= (const CORBA_IDLType_var &);
-    CORBA_IDLType_out &operator= (CORBA_IDLType_ptr);
-    operator CORBA_IDLType_ptr &();
-    CORBA_IDLType_ptr &ptr (void);
-    CORBA_IDLType_ptr operator-> (void);
 
-  private:
-    CORBA_IDLType_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_STRUCTDEF___OUT_CH_)
+#define _IR_STRUCTDEF___OUT_CH_
+
+class TAO_Export StructDef_out
+{
+public:
+  StructDef_out (StructDef_ptr &);
+  StructDef_out (StructDef_var &);
+  StructDef_out (const StructDef_out &);
+  StructDef_out &operator= (const StructDef_out &);
+  StructDef_out &operator= (const StructDef_var &);
+  StructDef_out &operator= (StructDef_ptr);
+  operator StructDef_ptr &();
+  StructDef_ptr &ptr (void);
+  StructDef_ptr operator-> (void);
+  
+private:
+  StructDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_STRUCTDEF___VAR_CH_)
-#define _CORBA_STRUCTDEF___VAR_CH_
+class UnionDef;
 
-  class TAO_Export CORBA_StructDef_var
-  {
-  public:
-    CORBA_StructDef_var (void); // default constructor
-    CORBA_StructDef_var (CORBA_StructDef_ptr);
-    CORBA_StructDef_var (const CORBA_StructDef_var &); // copy constructor
-    ~CORBA_StructDef_var (void); // destructor
+#if !defined (_IR_UNIONDEF___PTR_CH_)
+#define _IR_UNIONDEF___PTR_CH_
 
-    CORBA_StructDef_var &operator= (CORBA_StructDef_ptr);
-    CORBA_StructDef_var &operator= (const CORBA_StructDef_var &);
-    CORBA_StructDef_ptr operator-> (void) const;
+typedef UnionDef *UnionDef_ptr;
 
-    operator const CORBA_StructDef_ptr &() const;
-    operator CORBA_StructDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_StructDef_ptr in (void) const;
-    CORBA_StructDef_ptr &inout (void);
-    CORBA_StructDef_ptr &out (void);
-    CORBA_StructDef_ptr _retn (void);
-    CORBA_StructDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_StructDef_ptr ptr_;
-  };
+
+#if !defined (_IR_UNIONDEF___VAR_CH_)
+#define _IR_UNIONDEF___VAR_CH_
+
+class TAO_Export UnionDef_var
+{
+public:
+  UnionDef_var (void); // default constructor
+  UnionDef_var (UnionDef_ptr);
+  UnionDef_var (const UnionDef_var &); // copy constructor
+  ~UnionDef_var (void); // destructor
+  
+  UnionDef_var &operator= (UnionDef_ptr);
+  UnionDef_var &operator= (const UnionDef_var &);
+  UnionDef_ptr operator-> (void) const;
+  
+  operator const UnionDef_ptr &() const;
+  operator UnionDef_ptr &();
+  // in, inout, out, _retn 
+  UnionDef_ptr in (void) const;
+  UnionDef_ptr &inout (void);
+  UnionDef_ptr &out (void);
+  UnionDef_ptr _retn (void);
+  UnionDef_ptr ptr (void) const;
+
+private:
+  UnionDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRUCTDEF___OUT_CH_)
-#define _CORBA_STRUCTDEF___OUT_CH_
+#if !defined (_IR_UNIONDEF___OUT_CH_)
+#define _IR_UNIONDEF___OUT_CH_
 
-  class TAO_Export CORBA_StructDef_out
-  {
-  public:
-    CORBA_StructDef_out (CORBA_StructDef_ptr &);
-    CORBA_StructDef_out (CORBA_StructDef_var &);
-    CORBA_StructDef_out (const CORBA_StructDef_out &);
-    CORBA_StructDef_out &operator= (const CORBA_StructDef_out &);
-    CORBA_StructDef_out &operator= (const CORBA_StructDef_var &);
-    CORBA_StructDef_out &operator= (CORBA_StructDef_ptr);
-    operator CORBA_StructDef_ptr &();
-    CORBA_StructDef_ptr &ptr (void);
-    CORBA_StructDef_ptr operator-> (void);
+class TAO_Export UnionDef_out
+{
+public:
+  UnionDef_out (UnionDef_ptr &);
+  UnionDef_out (UnionDef_var &);
+  UnionDef_out (const UnionDef_out &);
+  UnionDef_out &operator= (const UnionDef_out &);
+  UnionDef_out &operator= (const UnionDef_var &);
+  UnionDef_out &operator= (UnionDef_ptr);
+  operator UnionDef_ptr &();
+  UnionDef_ptr &ptr (void);
+  UnionDef_ptr operator-> (void);
+  
+private:
+  UnionDef_ptr &ptr_;
+};
 
-  private:
-    CORBA_StructDef_ptr &ptr_;
-  };
 
+#endif /* end #if !defined */
+
+class EnumDef;
+
+#if !defined (_IR_ENUMDEF___PTR_CH_)
+#define _IR_ENUMDEF___PTR_CH_
+
+typedef EnumDef *EnumDef_ptr;
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_UNIONDEF___VAR_CH_)
-#define _CORBA_UNIONDEF___VAR_CH_
 
-  class TAO_Export CORBA_UnionDef_var
-  {
-  public:
-    CORBA_UnionDef_var (void); // default constructor
-    CORBA_UnionDef_var (CORBA_UnionDef_ptr);
-    CORBA_UnionDef_var (const CORBA_UnionDef_var &); // copy constructor
-    ~CORBA_UnionDef_var (void); // destructor
+#if !defined (_IR_ENUMDEF___VAR_CH_)
+#define _IR_ENUMDEF___VAR_CH_
+
+class TAO_Export EnumDef_var
+{
+public:
+  EnumDef_var (void); // default constructor
+  EnumDef_var (EnumDef_ptr);
+  EnumDef_var (const EnumDef_var &); // copy constructor
+  ~EnumDef_var (void); // destructor
+  
+  EnumDef_var &operator= (EnumDef_ptr);
+  EnumDef_var &operator= (const EnumDef_var &);
+  EnumDef_ptr operator-> (void) const;
+  
+  operator const EnumDef_ptr &() const;
+  operator EnumDef_ptr &();
+  // in, inout, out, _retn 
+  EnumDef_ptr in (void) const;
+  EnumDef_ptr &inout (void);
+  EnumDef_ptr &out (void);
+  EnumDef_ptr _retn (void);
+  EnumDef_ptr ptr (void) const;
+
+private:
+  EnumDef_ptr ptr_;
+};
 
-    CORBA_UnionDef_var &operator= (CORBA_UnionDef_ptr);
-    CORBA_UnionDef_var &operator= (const CORBA_UnionDef_var &);
-    CORBA_UnionDef_ptr operator-> (void) const;
 
-    operator const CORBA_UnionDef_ptr &() const;
-    operator CORBA_UnionDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_UnionDef_ptr in (void) const;
-    CORBA_UnionDef_ptr &inout (void);
-    CORBA_UnionDef_ptr &out (void);
-    CORBA_UnionDef_ptr _retn (void);
-    CORBA_UnionDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_UnionDef_ptr ptr_;
-  };
+
+#if !defined (_IR_ENUMDEF___OUT_CH_)
+#define _IR_ENUMDEF___OUT_CH_
+
+class TAO_Export EnumDef_out
+{
+public:
+  EnumDef_out (EnumDef_ptr &);
+  EnumDef_out (EnumDef_var &);
+  EnumDef_out (const EnumDef_out &);
+  EnumDef_out &operator= (const EnumDef_out &);
+  EnumDef_out &operator= (const EnumDef_var &);
+  EnumDef_out &operator= (EnumDef_ptr);
+  operator EnumDef_ptr &();
+  EnumDef_ptr &ptr (void);
+  EnumDef_ptr operator-> (void);
+  
+private:
+  EnumDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
+class AliasDef;
 
-#if !defined (_CORBA_UNIONDEF___OUT_CH_)
-#define _CORBA_UNIONDEF___OUT_CH_
+#if !defined (_IR_ALIASDEF___PTR_CH_)
+#define _IR_ALIASDEF___PTR_CH_
 
-  class TAO_Export CORBA_UnionDef_out
-  {
-  public:
-    CORBA_UnionDef_out (CORBA_UnionDef_ptr &);
-    CORBA_UnionDef_out (CORBA_UnionDef_var &);
-    CORBA_UnionDef_out (const CORBA_UnionDef_out &);
-    CORBA_UnionDef_out &operator= (const CORBA_UnionDef_out &);
-    CORBA_UnionDef_out &operator= (const CORBA_UnionDef_var &);
-    CORBA_UnionDef_out &operator= (CORBA_UnionDef_ptr);
-    operator CORBA_UnionDef_ptr &();
-    CORBA_UnionDef_ptr &ptr (void);
-    CORBA_UnionDef_ptr operator-> (void);
+typedef AliasDef *AliasDef_ptr;
 
-  private:
-    CORBA_UnionDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_ALIASDEF___VAR_CH_)
+#define _IR_ALIASDEF___VAR_CH_
+
+class TAO_Export AliasDef_var
+{
+public:
+  AliasDef_var (void); // default constructor
+  AliasDef_var (AliasDef_ptr);
+  AliasDef_var (const AliasDef_var &); // copy constructor
+  ~AliasDef_var (void); // destructor
+  
+  AliasDef_var &operator= (AliasDef_ptr);
+  AliasDef_var &operator= (const AliasDef_var &);
+  AliasDef_ptr operator-> (void) const;
+  
+  operator const AliasDef_ptr &() const;
+  operator AliasDef_ptr &();
+  // in, inout, out, _retn 
+  AliasDef_ptr in (void) const;
+  AliasDef_ptr &inout (void);
+  AliasDef_ptr &out (void);
+  AliasDef_ptr _retn (void);
+  AliasDef_ptr ptr (void) const;
+
+private:
+  AliasDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_ENUMDEF___VAR_CH_)
-#define _CORBA_ENUMDEF___VAR_CH_
 
-  class TAO_Export CORBA_EnumDef_var
-  {
-  public:
-    CORBA_EnumDef_var (void); // default constructor
-    CORBA_EnumDef_var (CORBA_EnumDef_ptr);
-    CORBA_EnumDef_var (const CORBA_EnumDef_var &); // copy constructor
-    ~CORBA_EnumDef_var (void); // destructor
+#if !defined (_IR_ALIASDEF___OUT_CH_)
+#define _IR_ALIASDEF___OUT_CH_
 
-    CORBA_EnumDef_var &operator= (CORBA_EnumDef_ptr);
-    CORBA_EnumDef_var &operator= (const CORBA_EnumDef_var &);
-    CORBA_EnumDef_ptr operator-> (void) const;
+class TAO_Export AliasDef_out
+{
+public:
+  AliasDef_out (AliasDef_ptr &);
+  AliasDef_out (AliasDef_var &);
+  AliasDef_out (const AliasDef_out &);
+  AliasDef_out &operator= (const AliasDef_out &);
+  AliasDef_out &operator= (const AliasDef_var &);
+  AliasDef_out &operator= (AliasDef_ptr);
+  operator AliasDef_ptr &();
+  AliasDef_ptr &ptr (void);
+  AliasDef_ptr operator-> (void);
+  
+private:
+  AliasDef_ptr &ptr_;
+};
 
-    operator const CORBA_EnumDef_ptr &() const;
-    operator CORBA_EnumDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_EnumDef_ptr in (void) const;
-    CORBA_EnumDef_ptr &inout (void);
-    CORBA_EnumDef_ptr &out (void);
-    CORBA_EnumDef_ptr _retn (void);
-    CORBA_EnumDef_ptr ptr (void) const;
 
-  private:
-    CORBA_EnumDef_ptr ptr_;
-  };
+#endif /* end #if !defined */
+
+class InterfaceDef;
+
+#if !defined (_IR_INTERFACEDEF___PTR_CH_)
+#define _IR_INTERFACEDEF___PTR_CH_
 
+typedef InterfaceDef *InterfaceDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ENUMDEF___OUT_CH_)
-#define _CORBA_ENUMDEF___OUT_CH_
+#if !defined (_IR_INTERFACEDEF___VAR_CH_)
+#define _IR_INTERFACEDEF___VAR_CH_
+
+class TAO_Export InterfaceDef_var
+{
+public:
+  InterfaceDef_var (void); // default constructor
+  InterfaceDef_var (InterfaceDef_ptr);
+  InterfaceDef_var (const InterfaceDef_var &); // copy constructor
+  ~InterfaceDef_var (void); // destructor
+  
+  InterfaceDef_var &operator= (InterfaceDef_ptr);
+  InterfaceDef_var &operator= (const InterfaceDef_var &);
+  InterfaceDef_ptr operator-> (void) const;
+  
+  operator const InterfaceDef_ptr &() const;
+  operator InterfaceDef_ptr &();
+  // in, inout, out, _retn 
+  InterfaceDef_ptr in (void) const;
+  InterfaceDef_ptr &inout (void);
+  InterfaceDef_ptr &out (void);
+  InterfaceDef_ptr _retn (void);
+  InterfaceDef_ptr ptr (void) const;
+
+private:
+  InterfaceDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_EnumDef_out
-  {
-  public:
-    CORBA_EnumDef_out (CORBA_EnumDef_ptr &);
-    CORBA_EnumDef_out (CORBA_EnumDef_var &);
-    CORBA_EnumDef_out (const CORBA_EnumDef_out &);
-    CORBA_EnumDef_out &operator= (const CORBA_EnumDef_out &);
-    CORBA_EnumDef_out &operator= (const CORBA_EnumDef_var &);
-    CORBA_EnumDef_out &operator= (CORBA_EnumDef_ptr);
-    operator CORBA_EnumDef_ptr &();
-    CORBA_EnumDef_ptr &ptr (void);
-    CORBA_EnumDef_ptr operator-> (void);
 
-  private:
-    CORBA_EnumDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_INTERFACEDEF___OUT_CH_)
+#define _IR_INTERFACEDEF___OUT_CH_
+
+class TAO_Export InterfaceDef_out
+{
+public:
+  InterfaceDef_out (InterfaceDef_ptr &);
+  InterfaceDef_out (InterfaceDef_var &);
+  InterfaceDef_out (const InterfaceDef_out &);
+  InterfaceDef_out &operator= (const InterfaceDef_out &);
+  InterfaceDef_out &operator= (const InterfaceDef_var &);
+  InterfaceDef_out &operator= (InterfaceDef_ptr);
+  operator InterfaceDef_ptr &();
+  InterfaceDef_ptr &ptr (void);
+  InterfaceDef_ptr operator-> (void);
+  
+private:
+  InterfaceDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_ALIASDEF___VAR_CH_)
-#define _CORBA_ALIASDEF___VAR_CH_
+class ExceptionDef;
 
-  class TAO_Export CORBA_AliasDef_var
-  {
-  public:
-    CORBA_AliasDef_var (void); // default constructor
-    CORBA_AliasDef_var (CORBA_AliasDef_ptr);
-    CORBA_AliasDef_var (const CORBA_AliasDef_var &); // copy constructor
-    ~CORBA_AliasDef_var (void); // destructor
+#if !defined (_IR_EXCEPTIONDEF___PTR_CH_)
+#define _IR_EXCEPTIONDEF___PTR_CH_
 
-    CORBA_AliasDef_var &operator= (CORBA_AliasDef_ptr);
-    CORBA_AliasDef_var &operator= (const CORBA_AliasDef_var &);
-    CORBA_AliasDef_ptr operator-> (void) const;
+typedef ExceptionDef *ExceptionDef_ptr;
 
-    operator const CORBA_AliasDef_ptr &() const;
-    operator CORBA_AliasDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_AliasDef_ptr in (void) const;
-    CORBA_AliasDef_ptr &inout (void);
-    CORBA_AliasDef_ptr &out (void);
-    CORBA_AliasDef_ptr _retn (void);
-    CORBA_AliasDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_AliasDef_ptr ptr_;
-  };
+
+#if !defined (_IR_EXCEPTIONDEF___VAR_CH_)
+#define _IR_EXCEPTIONDEF___VAR_CH_
+
+class TAO_Export ExceptionDef_var
+{
+public:
+  ExceptionDef_var (void); // default constructor
+  ExceptionDef_var (ExceptionDef_ptr);
+  ExceptionDef_var (const ExceptionDef_var &); // copy constructor
+  ~ExceptionDef_var (void); // destructor
+  
+  ExceptionDef_var &operator= (ExceptionDef_ptr);
+  ExceptionDef_var &operator= (const ExceptionDef_var &);
+  ExceptionDef_ptr operator-> (void) const;
+  
+  operator const ExceptionDef_ptr &() const;
+  operator ExceptionDef_ptr &();
+  // in, inout, out, _retn 
+  ExceptionDef_ptr in (void) const;
+  ExceptionDef_ptr &inout (void);
+  ExceptionDef_ptr &out (void);
+  ExceptionDef_ptr _retn (void);
+  ExceptionDef_ptr ptr (void) const;
+
+private:
+  ExceptionDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ALIASDEF___OUT_CH_)
-#define _CORBA_ALIASDEF___OUT_CH_
+#if !defined (_IR_EXCEPTIONDEF___OUT_CH_)
+#define _IR_EXCEPTIONDEF___OUT_CH_
 
-  class TAO_Export CORBA_AliasDef_out
-  {
-  public:
-    CORBA_AliasDef_out (CORBA_AliasDef_ptr &);
-    CORBA_AliasDef_out (CORBA_AliasDef_var &);
-    CORBA_AliasDef_out (const CORBA_AliasDef_out &);
-    CORBA_AliasDef_out &operator= (const CORBA_AliasDef_out &);
-    CORBA_AliasDef_out &operator= (const CORBA_AliasDef_var &);
-    CORBA_AliasDef_out &operator= (CORBA_AliasDef_ptr);
-    operator CORBA_AliasDef_ptr &();
-    CORBA_AliasDef_ptr &ptr (void);
-    CORBA_AliasDef_ptr operator-> (void);
+class TAO_Export ExceptionDef_out
+{
+public:
+  ExceptionDef_out (ExceptionDef_ptr &);
+  ExceptionDef_out (ExceptionDef_var &);
+  ExceptionDef_out (const ExceptionDef_out &);
+  ExceptionDef_out &operator= (const ExceptionDef_out &);
+  ExceptionDef_out &operator= (const ExceptionDef_var &);
+  ExceptionDef_out &operator= (ExceptionDef_ptr);
+  operator ExceptionDef_ptr &();
+  ExceptionDef_ptr &ptr (void);
+  ExceptionDef_ptr operator-> (void);
+  
+private:
+  ExceptionDef_ptr &ptr_;
+};
 
-  private:
-    CORBA_AliasDef_ptr &ptr_;
-  };
 
+#endif /* end #if !defined */
+
+class NativeDef;
+
+#if !defined (_IR_NATIVEDEF___PTR_CH_)
+#define _IR_NATIVEDEF___PTR_CH_
+
+typedef NativeDef *NativeDef_ptr;
 
 #endif /* end #if !defined */
 
-//#endif /* end #if !defined */
 
+#if !defined (_IR_NATIVEDEF___VAR_CH_)
+#define _IR_NATIVEDEF___VAR_CH_
+
+class TAO_Export NativeDef_var
+{
+public:
+  NativeDef_var (void); // default constructor
+  NativeDef_var (NativeDef_ptr);
+  NativeDef_var (const NativeDef_var &); // copy constructor
+  ~NativeDef_var (void); // destructor
+  
+  NativeDef_var &operator= (NativeDef_ptr);
+  NativeDef_var &operator= (const NativeDef_var &);
+  NativeDef_ptr operator-> (void) const;
+  
+  operator const NativeDef_ptr &() const;
+  operator NativeDef_ptr &();
+  // in, inout, out, _retn 
+  NativeDef_ptr in (void) const;
+  NativeDef_ptr &inout (void);
+  NativeDef_ptr &out (void);
+  NativeDef_ptr _retn (void);
+  NativeDef_ptr ptr (void) const;
+
+private:
+  NativeDef_ptr ptr_;
+};
 
-#if !defined (_CORBA_INTERFACEDEF___VAR_CH_)
-#define _CORBA_INTERFACEDEF___VAR_CH_
 
-  class TAO_Export CORBA_InterfaceDef_var
-  {
-  public:
-    CORBA_InterfaceDef_var (void); // default constructor
-    CORBA_InterfaceDef_var (CORBA_InterfaceDef_ptr);
-    CORBA_InterfaceDef_var (const CORBA_InterfaceDef_var &); // copy constructor
-    ~CORBA_InterfaceDef_var (void); // destructor
+#endif /* end #if !defined */
 
-    CORBA_InterfaceDef_var &operator= (CORBA_InterfaceDef_ptr);
-    CORBA_InterfaceDef_var &operator= (const CORBA_InterfaceDef_var &);
-    CORBA_InterfaceDef_ptr operator-> (void) const;
 
-    operator const CORBA_InterfaceDef_ptr &() const;
-    operator CORBA_InterfaceDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_InterfaceDef_ptr in (void) const;
-    CORBA_InterfaceDef_ptr &inout (void);
-    CORBA_InterfaceDef_ptr &out (void);
-    CORBA_InterfaceDef_ptr _retn (void);
-    CORBA_InterfaceDef_ptr ptr (void) const;
+#if !defined (_IR_NATIVEDEF___OUT_CH_)
+#define _IR_NATIVEDEF___OUT_CH_
 
-  private:
-    CORBA_InterfaceDef_ptr ptr_;
-  };
+class TAO_Export NativeDef_out
+{
+public:
+  NativeDef_out (NativeDef_ptr &);
+  NativeDef_out (NativeDef_var &);
+  NativeDef_out (const NativeDef_out &);
+  NativeDef_out &operator= (const NativeDef_out &);
+  NativeDef_out &operator= (const NativeDef_var &);
+  NativeDef_out &operator= (NativeDef_ptr);
+  operator NativeDef_ptr &();
+  NativeDef_ptr &ptr (void);
+  NativeDef_ptr operator-> (void);
+  
+private:
+  NativeDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_INTERFACEDEF___OUT_CH_)
-#define _CORBA_INTERFACEDEF___OUT_CH_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_INTERFACEDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_INTERFACEDEFSEQ_CH_
 
-  class TAO_Export CORBA_InterfaceDef_out
+  class _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_InterfaceDef_out (CORBA_InterfaceDef_ptr &);
-    CORBA_InterfaceDef_out (CORBA_InterfaceDef_var &);
-    CORBA_InterfaceDef_out (const CORBA_InterfaceDef_out &);
-    CORBA_InterfaceDef_out &operator= (const CORBA_InterfaceDef_out &);
-    CORBA_InterfaceDef_out &operator= (const CORBA_InterfaceDef_var &);
-    CORBA_InterfaceDef_out &operator= (CORBA_InterfaceDef_ptr);
-    operator CORBA_InterfaceDef_ptr &();
-    CORBA_InterfaceDef_ptr &ptr (void);
-    CORBA_InterfaceDef_ptr operator-> (void);
-
-  private:
-    CORBA_InterfaceDef_ptr &ptr_;
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      InterfaceDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &rhs);
+    TAO_Object_Manager<IR::InterfaceDef,IR::InterfaceDef_var> operator[] (CORBA::ULong index) const;
+    static InterfaceDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (InterfaceDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    InterfaceDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const InterfaceDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_INTERFACEDEFSEQ_CH_)
+#define _IR_INTERFACEDEFSEQ_CH_
+
+class InterfaceDefSeq;
+class InterfaceDefSeq_var;
+
+// *************************************************************
+// InterfaceDefSeq
+// *************************************************************
+
+class TAO_Export InterfaceDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<InterfaceDef,InterfaceDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  InterfaceDefSeq (void); // default ctor
+  InterfaceDefSeq (CORBA::ULong max); // uses max size
+  InterfaceDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    InterfaceDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  InterfaceDefSeq (const InterfaceDefSeq &); // copy ctor
+  ~InterfaceDefSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef InterfaceDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_EXCEPTIONDEF___VAR_CH_)
-#define _CORBA_EXCEPTIONDEF___VAR_CH_
 
-  class TAO_Export CORBA_ExceptionDef_var
-  {
-  public:
-    CORBA_ExceptionDef_var (void); // default constructor
-    CORBA_ExceptionDef_var (CORBA_ExceptionDef_ptr);
-    CORBA_ExceptionDef_var (const CORBA_ExceptionDef_var &); // copy constructor
-    ~CORBA_ExceptionDef_var (void); // destructor
+#if !defined (_IR_INTERFACEDEFSEQ___VAR_CH_)
+#define _IR_INTERFACEDEFSEQ___VAR_CH_
 
-    CORBA_ExceptionDef_var &operator= (CORBA_ExceptionDef_ptr);
-    CORBA_ExceptionDef_var &operator= (const CORBA_ExceptionDef_var &);
-    CORBA_ExceptionDef_ptr operator-> (void) const;
+// *************************************************************
+// class IR::InterfaceDefSeq_var
+// *************************************************************
 
-    operator const CORBA_ExceptionDef_ptr &() const;
-    operator CORBA_ExceptionDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ExceptionDef_ptr in (void) const;
-    CORBA_ExceptionDef_ptr &inout (void);
-    CORBA_ExceptionDef_ptr &out (void);
-    CORBA_ExceptionDef_ptr _retn (void);
-    CORBA_ExceptionDef_ptr ptr (void) const;
+class TAO_Export InterfaceDefSeq_var
+{
+public:
+  InterfaceDefSeq_var (void); // default constructor
+  InterfaceDefSeq_var (InterfaceDefSeq *);
+  InterfaceDefSeq_var (const InterfaceDefSeq_var &); // copy constructor
+  ~InterfaceDefSeq_var (void); // destructor
+  
+  InterfaceDefSeq_var &operator= (InterfaceDefSeq *);
+  InterfaceDefSeq_var &operator= (const InterfaceDefSeq_var &);
+  InterfaceDefSeq *operator-> (void);
+  const InterfaceDefSeq *operator-> (void) const;
+  
+  operator const InterfaceDefSeq &() const;
+  operator InterfaceDefSeq &();
+  operator InterfaceDefSeq &() const;
+  operator InterfaceDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<InterfaceDef, InterfaceDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const InterfaceDefSeq &in (void) const;
+  InterfaceDefSeq &inout (void);
+  InterfaceDefSeq *&out (void);
+  InterfaceDefSeq *_retn (void);
+  InterfaceDefSeq *ptr (void) const;
+
+private:
+  InterfaceDefSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
 
-  private:
-    CORBA_ExceptionDef_ptr ptr_;
-  };
+
+#if !defined (_IR_INTERFACEDEFSEQ___OUT_CH_)
+#define _IR_INTERFACEDEFSEQ___OUT_CH_
+
+class TAO_Export InterfaceDefSeq_out
+{
+public:
+  InterfaceDefSeq_out (InterfaceDefSeq *&);
+  InterfaceDefSeq_out (InterfaceDefSeq_var &);
+  InterfaceDefSeq_out (const InterfaceDefSeq_out &);
+  InterfaceDefSeq_out &operator= (const InterfaceDefSeq_out &);
+  InterfaceDefSeq_out &operator= (InterfaceDefSeq *);
+  operator InterfaceDefSeq *&();
+  InterfaceDefSeq *&ptr (void);
+  InterfaceDefSeq *operator-> (void);
+  TAO_Object_Manager<InterfaceDef, InterfaceDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  InterfaceDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const InterfaceDefSeq_var &);
+};
 
 
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDefSeq;
 
-#if !defined (_CORBA_EXCEPTIONDEF___OUT_CH_)
-#define _CORBA_EXCEPTIONDEF___OUT_CH_
+class ValueDef;
 
-  class TAO_Export CORBA_ExceptionDef_out
-  {
-  public:
-    CORBA_ExceptionDef_out (CORBA_ExceptionDef_ptr &);
-    CORBA_ExceptionDef_out (CORBA_ExceptionDef_var &);
-    CORBA_ExceptionDef_out (const CORBA_ExceptionDef_out &);
-    CORBA_ExceptionDef_out &operator= (const CORBA_ExceptionDef_out &);
-    CORBA_ExceptionDef_out &operator= (const CORBA_ExceptionDef_var &);
-    CORBA_ExceptionDef_out &operator= (CORBA_ExceptionDef_ptr);
-    operator CORBA_ExceptionDef_ptr &();
-    CORBA_ExceptionDef_ptr &ptr (void);
-    CORBA_ExceptionDef_ptr operator-> (void);
+#if !defined (_IR_VALUEDEF___PTR_CH_)
+#define _IR_VALUEDEF___PTR_CH_
 
-  private:
-    CORBA_ExceptionDef_ptr &ptr_;
-  };
+typedef ValueDef *ValueDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_VALUEDEF___VAR_CH_)
+#define _IR_VALUEDEF___VAR_CH_
+
+class TAO_Export ValueDef_var
+{
+public:
+  ValueDef_var (void); // default constructor
+  ValueDef_var (ValueDef_ptr);
+  ValueDef_var (const ValueDef_var &); // copy constructor
+  ~ValueDef_var (void); // destructor
+  
+  ValueDef_var &operator= (ValueDef_ptr);
+  ValueDef_var &operator= (const ValueDef_var &);
+  ValueDef_ptr operator-> (void) const;
+  
+  operator const ValueDef_ptr &() const;
+  operator ValueDef_ptr &();
+  // in, inout, out, _retn 
+  ValueDef_ptr in (void) const;
+  ValueDef_ptr &inout (void);
+  ValueDef_ptr &out (void);
+  ValueDef_ptr _retn (void);
+  ValueDef_ptr ptr (void) const;
+
+private:
+  ValueDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_NATIVEDEF___VAR_CH_)
-#define _CORBA_NATIVEDEF___VAR_CH_
+#if !defined (_IR_VALUEDEF___OUT_CH_)
+#define _IR_VALUEDEF___OUT_CH_
 
-  class TAO_Export CORBA_NativeDef_var
+class TAO_Export ValueDef_out
+{
+public:
+  ValueDef_out (ValueDef_ptr &);
+  ValueDef_out (ValueDef_var &);
+  ValueDef_out (const ValueDef_out &);
+  ValueDef_out &operator= (const ValueDef_out &);
+  ValueDef_out &operator= (const ValueDef_var &);
+  ValueDef_out &operator= (ValueDef_ptr);
+  operator ValueDef_ptr &();
+  ValueDef_ptr &ptr (void);
+  ValueDef_ptr operator-> (void);
+  
+private:
+  ValueDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_VALUEDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_VALUEDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_NativeDef_var (void); // default constructor
-    CORBA_NativeDef_var (CORBA_NativeDef_ptr);
-    CORBA_NativeDef_var (const CORBA_NativeDef_var &); // copy constructor
-    ~CORBA_NativeDef_var (void); // destructor
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      ValueDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &rhs);
+    TAO_Object_Manager<IR::ValueDef,IR::ValueDef_var> operator[] (CORBA::ULong index) const;
+    static ValueDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (ValueDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    ValueDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const ValueDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
+  };
 
-    CORBA_NativeDef_var &operator= (CORBA_NativeDef_ptr);
-    CORBA_NativeDef_var &operator= (const CORBA_NativeDef_var &);
-    CORBA_NativeDef_ptr operator-> (void) const;
+#endif /* end #if !defined */
 
-    operator const CORBA_NativeDef_ptr &() const;
-    operator CORBA_NativeDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_NativeDef_ptr in (void) const;
-    CORBA_NativeDef_ptr &inout (void);
-    CORBA_NativeDef_ptr &out (void);
-    CORBA_NativeDef_ptr _retn (void);
-    CORBA_NativeDef_ptr ptr (void) const;
 
-  private:
-    CORBA_NativeDef_ptr ptr_;
-  };
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
+#if !defined (_IR_VALUEDEFSEQ_CH_)
+#define _IR_VALUEDEFSEQ_CH_
+
+class ValueDefSeq;
+class ValueDefSeq_var;
+
+// *************************************************************
+// ValueDefSeq
+// *************************************************************
+
+class TAO_Export ValueDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<ValueDef,ValueDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ValueDefSeq (void); // default ctor
+  ValueDefSeq (CORBA::ULong max); // uses max size
+  ValueDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ValueDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  ValueDefSeq (const ValueDefSeq &); // copy ctor
+  ~ValueDefSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ValueDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_NATIVEDEF___OUT_CH_)
-#define _CORBA_NATIVEDEF___OUT_CH_
+#if !defined (_IR_VALUEDEFSEQ___VAR_CH_)
+#define _IR_VALUEDEFSEQ___VAR_CH_
 
-  class TAO_Export CORBA_NativeDef_out
-  {
-  public:
-    CORBA_NativeDef_out (CORBA_NativeDef_ptr &);
-    CORBA_NativeDef_out (CORBA_NativeDef_var &);
-    CORBA_NativeDef_out (const CORBA_NativeDef_out &);
-    CORBA_NativeDef_out &operator= (const CORBA_NativeDef_out &);
-    CORBA_NativeDef_out &operator= (const CORBA_NativeDef_var &);
-    CORBA_NativeDef_out &operator= (CORBA_NativeDef_ptr);
-    operator CORBA_NativeDef_ptr &();
-    CORBA_NativeDef_ptr &ptr (void);
-    CORBA_NativeDef_ptr operator-> (void);
+// *************************************************************
+// class IR::ValueDefSeq_var
+// *************************************************************
 
-  private:
-    CORBA_NativeDef_ptr &ptr_;
-  };
+class TAO_Export ValueDefSeq_var
+{
+public:
+  ValueDefSeq_var (void); // default constructor
+  ValueDefSeq_var (ValueDefSeq *);
+  ValueDefSeq_var (const ValueDefSeq_var &); // copy constructor
+  ~ValueDefSeq_var (void); // destructor
+  
+  ValueDefSeq_var &operator= (ValueDefSeq *);
+  ValueDefSeq_var &operator= (const ValueDefSeq_var &);
+  ValueDefSeq *operator-> (void);
+  const ValueDefSeq *operator-> (void) const;
+  
+  operator const ValueDefSeq &() const;
+  operator ValueDefSeq &();
+  operator ValueDefSeq &() const;
+  operator ValueDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<ValueDef, ValueDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ValueDefSeq &in (void) const;
+  ValueDefSeq &inout (void);
+  ValueDefSeq *&out (void);
+  ValueDefSeq *_retn (void);
+  ValueDefSeq *ptr (void) const;
+
+private:
+  ValueDefSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+#if !defined (_IR_VALUEDEFSEQ___OUT_CH_)
+#define _IR_VALUEDEFSEQ___OUT_CH_
+
+class TAO_Export ValueDefSeq_out
+{
+public:
+  ValueDefSeq_out (ValueDefSeq *&);
+  ValueDefSeq_out (ValueDefSeq_var &);
+  ValueDefSeq_out (const ValueDefSeq_out &);
+  ValueDefSeq_out &operator= (const ValueDefSeq_out &);
+  ValueDefSeq_out &operator= (ValueDefSeq *);
+  operator ValueDefSeq *&();
+  ValueDefSeq *&ptr (void);
+  ValueDefSeq *operator-> (void);
+  TAO_Object_Manager<ValueDef, ValueDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  ValueDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ValueDefSeq_var &);
+};
 
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CH_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CH_
 
-    class _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+#endif /* end #if !defined */
 
-      _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void);
-      _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_InterfaceDef* *value,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs);
-      virtual ~_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void);
-      _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs);
-      TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> operator[] (CORBA::ULong index) const;
-      static CORBA_InterfaceDef **allocbuf (CORBA::ULong nelems);
-      static void freebuf (CORBA_InterfaceDef **buffer);
-      // The Base_Sequence functions, please see tao/Sequence.h
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      CORBA_InterfaceDef* *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_InterfaceDef* *get_buffer (void) const;
-      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
-      virtual void _downcast (
-          void* target,
-          CORBA_Object *src,
-          CORBA_Environment &ACE_TRY_ENV =
-            TAO_default_environment ()
-        );
-      virtual CORBA_Object* _upcast (void *src) const;
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDefSeq;
 
-    };
+class ValueBoxDef;
+
+#if !defined (_IR_VALUEBOXDEF___PTR_CH_)
+#define _IR_VALUEBOXDEF___PTR_CH_
+
+typedef ValueBoxDef *ValueBoxDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_VALUEBOXDEF___VAR_CH_)
+#define _IR_VALUEBOXDEF___VAR_CH_
+
+class TAO_Export ValueBoxDef_var
+{
+public:
+  ValueBoxDef_var (void); // default constructor
+  ValueBoxDef_var (ValueBoxDef_ptr);
+  ValueBoxDef_var (const ValueBoxDef_var &); // copy constructor
+  ~ValueBoxDef_var (void); // destructor
+  
+  ValueBoxDef_var &operator= (ValueBoxDef_ptr);
+  ValueBoxDef_var &operator= (const ValueBoxDef_var &);
+  ValueBoxDef_ptr operator-> (void) const;
+  
+  operator const ValueBoxDef_ptr &() const;
+  operator ValueBoxDef_ptr &();
+  // in, inout, out, _retn 
+  ValueBoxDef_ptr in (void) const;
+  ValueBoxDef_ptr &inout (void);
+  ValueBoxDef_ptr &out (void);
+  ValueBoxDef_ptr _retn (void);
+  ValueBoxDef_ptr ptr (void) const;
+
+private:
+  ValueBoxDef_ptr ptr_;
+};
 
-#if !defined (_CORBA_INTERFACEDEFSEQ_CH_)
-#define _CORBA_INTERFACEDEFSEQ_CH_
 
-  // *************************************************************
-  // InterfaceDefSeq
-  // *************************************************************
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_VALUEBOXDEF___OUT_CH_)
+#define _IR_VALUEBOXDEF___OUT_CH_
+
+class TAO_Export ValueBoxDef_out
+{
+public:
+  ValueBoxDef_out (ValueBoxDef_ptr &);
+  ValueBoxDef_out (ValueBoxDef_var &);
+  ValueBoxDef_out (const ValueBoxDef_out &);
+  ValueBoxDef_out &operator= (const ValueBoxDef_out &);
+  ValueBoxDef_out &operator= (const ValueBoxDef_var &);
+  ValueBoxDef_out &operator= (ValueBoxDef_ptr);
+  operator ValueBoxDef_ptr &();
+  ValueBoxDef_ptr &ptr (void);
+  ValueBoxDef_ptr operator-> (void);
+  
+private:
+  ValueBoxDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+class ComponentDef;
+
+#if !defined (_IR_COMPONENTDEF___PTR_CH_)
+#define _IR_COMPONENTDEF___PTR_CH_
+
+typedef ComponentDef *ComponentDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEF___VAR_CH_)
+#define _IR_COMPONENTDEF___VAR_CH_
+
+class TAO_Export ComponentDef_var
+{
+public:
+  ComponentDef_var (void); // default constructor
+  ComponentDef_var (ComponentDef_ptr);
+  ComponentDef_var (const ComponentDef_var &); // copy constructor
+  ~ComponentDef_var (void); // destructor
+  
+  ComponentDef_var &operator= (ComponentDef_ptr);
+  ComponentDef_var &operator= (const ComponentDef_var &);
+  ComponentDef_ptr operator-> (void) const;
+  
+  operator const ComponentDef_ptr &() const;
+  operator ComponentDef_ptr &();
+  // in, inout, out, _retn 
+  ComponentDef_ptr in (void) const;
+  ComponentDef_ptr &inout (void);
+  ComponentDef_ptr &out (void);
+  ComponentDef_ptr _retn (void);
+  ComponentDef_ptr ptr (void) const;
+
+private:
+  ComponentDef_ptr ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEF___OUT_CH_)
+#define _IR_COMPONENTDEF___OUT_CH_
+
+class TAO_Export ComponentDef_out
+{
+public:
+  ComponentDef_out (ComponentDef_ptr &);
+  ComponentDef_out (ComponentDef_var &);
+  ComponentDef_out (const ComponentDef_out &);
+  ComponentDef_out &operator= (const ComponentDef_out &);
+  ComponentDef_out &operator= (const ComponentDef_var &);
+  ComponentDef_out &operator= (ComponentDef_ptr);
+  operator ComponentDef_ptr &();
+  ComponentDef_ptr &ptr (void);
+  ComponentDef_ptr operator-> (void);
+  
+private:
+  ComponentDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
 
-  class TAO_Export CORBA_InterfaceDefSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Object_Sequence<CORBA_InterfaceDef,CORBA_InterfaceDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_InterfaceDefSeq (void); // default ctor
-    CORBA_InterfaceDefSeq (CORBA::ULong max); // uses max size
-    CORBA_InterfaceDefSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      CORBA_InterfaceDef_ptr *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_InterfaceDefSeq (const CORBA_InterfaceDefSeq &); // copy ctor
-    ~CORBA_InterfaceDefSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      ComponentDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs);
+    TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var> operator[] (CORBA::ULong index) const;
+    static ComponentDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (ComponentDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    ComponentDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const ComponentDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_INTERFACEDEFSEQ___VAR_CH_)
-#define _CORBA_INTERFACEDEFSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_COMPONENTDEFSEQ_CH_)
+#define _IR_COMPONENTDEFSEQ_CH_
+
+class ComponentDefSeq;
+class ComponentDefSeq_var;
 
 // *************************************************************
-  // class CORBA::InterfaceDefSeq_var
-  // *************************************************************
+// ComponentDefSeq
+// *************************************************************
 
-  class TAO_Export CORBA_InterfaceDefSeq_var
-  {
-  public:
-    CORBA_InterfaceDefSeq_var (void); // default constructor
-    CORBA_InterfaceDefSeq_var (CORBA_InterfaceDefSeq *);
-    CORBA_InterfaceDefSeq_var (const CORBA_InterfaceDefSeq_var &); // copy constructor
-    ~CORBA_InterfaceDefSeq_var (void); // destructor
-
-    CORBA_InterfaceDefSeq_var &operator= (CORBA_InterfaceDefSeq *);
-    CORBA_InterfaceDefSeq_var &operator= (const CORBA_InterfaceDefSeq_var &);
-    CORBA_InterfaceDefSeq *operator-> (void);
-    const CORBA_InterfaceDefSeq *operator-> (void) const;
-
-    operator const CORBA_InterfaceDefSeq &() const;
-    operator CORBA_InterfaceDefSeq &();
-    operator CORBA_InterfaceDefSeq &() const;
-    TAO_Object_Manager<CORBA_InterfaceDef,CORBA_InterfaceDef_var> operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_InterfaceDefSeq &in (void) const;
-    CORBA_InterfaceDefSeq &inout (void);
-    CORBA_InterfaceDefSeq *&out (void);
-    CORBA_InterfaceDefSeq *_retn (void);
-    CORBA_InterfaceDefSeq *ptr (void) const;
+class TAO_Export ComponentDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<ComponentDef,ComponentDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ComponentDefSeq (void); // default ctor
+  ComponentDefSeq (CORBA::ULong max); // uses max size
+  ComponentDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ComponentDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  ComponentDefSeq (const ComponentDefSeq &); // copy ctor
+  ~ComponentDefSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_InterfaceDefSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ComponentDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_INTERFACEDEFSEQ___OUT_CH_)
-#define _CORBA_INTERFACEDEFSEQ___OUT_CH_
+#if !defined (_IR_COMPONENTDEFSEQ___VAR_CH_)
+#define _IR_COMPONENTDEFSEQ___VAR_CH_
 
-  class TAO_Export CORBA_InterfaceDefSeq_out
-  {
-  public:
-    CORBA_InterfaceDefSeq_out (CORBA_InterfaceDefSeq *&);
-    CORBA_InterfaceDefSeq_out (CORBA_InterfaceDefSeq_var &);
-    CORBA_InterfaceDefSeq_out (const CORBA_InterfaceDefSeq_out &);
-    CORBA_InterfaceDefSeq_out &operator= (const CORBA_InterfaceDefSeq_out &);
-    CORBA_InterfaceDefSeq_out &operator= (CORBA_InterfaceDefSeq *);
-    operator CORBA_InterfaceDefSeq *&();
-    CORBA_InterfaceDefSeq *&ptr (void);
-    CORBA_InterfaceDefSeq *operator-> (void);
-    TAO_Object_Manager<CORBA_InterfaceDef,CORBA_InterfaceDef_var> operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::ComponentDefSeq_var
+// *************************************************************
 
-  private:
-    CORBA_InterfaceDefSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_InterfaceDefSeq_var &);
-  };
+class TAO_Export ComponentDefSeq_var
+{
+public:
+  ComponentDefSeq_var (void); // default constructor
+  ComponentDefSeq_var (ComponentDefSeq *);
+  ComponentDefSeq_var (const ComponentDefSeq_var &); // copy constructor
+  ~ComponentDefSeq_var (void); // destructor
+  
+  ComponentDefSeq_var &operator= (ComponentDefSeq *);
+  ComponentDefSeq_var &operator= (const ComponentDefSeq_var &);
+  ComponentDefSeq *operator-> (void);
+  const ComponentDefSeq *operator-> (void) const;
+  
+  operator const ComponentDefSeq &() const;
+  operator ComponentDefSeq &();
+  operator ComponentDefSeq &() const;
+  operator ComponentDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<ComponentDef, ComponentDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ComponentDefSeq &in (void) const;
+  ComponentDefSeq &inout (void);
+  ComponentDefSeq *&out (void);
+  ComponentDefSeq *_retn (void);
+  ComponentDefSeq *ptr (void) const;
+
+private:
+  ComponentDefSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_VALUEDEF___VAR_CH_)
-#define _CORBA_VALUEDEF___VAR_CH_
 
-  class TAO_Export CORBA_ValueDef_var
-  {
-  public:
-    CORBA_ValueDef_var (void); // default constructor
-    CORBA_ValueDef_var (CORBA_ValueDef_ptr);
-    CORBA_ValueDef_var (const CORBA_ValueDef_var &); // copy constructor
-    ~CORBA_ValueDef_var (void); // destructor
+#if !defined (_IR_COMPONENTDEFSEQ___OUT_CH_)
+#define _IR_COMPONENTDEFSEQ___OUT_CH_
+
+class TAO_Export ComponentDefSeq_out
+{
+public:
+  ComponentDefSeq_out (ComponentDefSeq *&);
+  ComponentDefSeq_out (ComponentDefSeq_var &);
+  ComponentDefSeq_out (const ComponentDefSeq_out &);
+  ComponentDefSeq_out &operator= (const ComponentDefSeq_out &);
+  ComponentDefSeq_out &operator= (ComponentDefSeq *);
+  operator ComponentDefSeq *&();
+  ComponentDefSeq *&ptr (void);
+  ComponentDefSeq *operator-> (void);
+  TAO_Object_Manager<ComponentDef, ComponentDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  ComponentDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ComponentDefSeq_var &);
+};
 
-    CORBA_ValueDef_var &operator= (CORBA_ValueDef_ptr);
-    CORBA_ValueDef_var &operator= (const CORBA_ValueDef_var &);
-    CORBA_ValueDef_ptr operator-> (void) const;
 
-    operator const CORBA_ValueDef_ptr &() const;
-    operator CORBA_ValueDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ValueDef_ptr in (void) const;
-    CORBA_ValueDef_ptr &inout (void);
-    CORBA_ValueDef_ptr &out (void);
-    CORBA_ValueDef_ptr _retn (void);
-    CORBA_ValueDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_ValueDef_ptr ptr_;
-  };
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDefSeq;
+
+class ProvidesDef;
 
+#if !defined (_IR_PROVIDESDEF___PTR_CH_)
+#define _IR_PROVIDESDEF___PTR_CH_
+
+typedef ProvidesDef *ProvidesDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEDEF___OUT_CH_)
-#define _CORBA_VALUEDEF___OUT_CH_
+#if !defined (_IR_PROVIDESDEF___VAR_CH_)
+#define _IR_PROVIDESDEF___VAR_CH_
+
+class TAO_Export ProvidesDef_var
+{
+public:
+  ProvidesDef_var (void); // default constructor
+  ProvidesDef_var (ProvidesDef_ptr);
+  ProvidesDef_var (const ProvidesDef_var &); // copy constructor
+  ~ProvidesDef_var (void); // destructor
+  
+  ProvidesDef_var &operator= (ProvidesDef_ptr);
+  ProvidesDef_var &operator= (const ProvidesDef_var &);
+  ProvidesDef_ptr operator-> (void) const;
+  
+  operator const ProvidesDef_ptr &() const;
+  operator ProvidesDef_ptr &();
+  // in, inout, out, _retn 
+  ProvidesDef_ptr in (void) const;
+  ProvidesDef_ptr &inout (void);
+  ProvidesDef_ptr &out (void);
+  ProvidesDef_ptr _retn (void);
+  ProvidesDef_ptr ptr (void) const;
+
+private:
+  ProvidesDef_ptr ptr_;
+};
+
+
+#endif /* end #if !defined */
+
 
-  class TAO_Export CORBA_ValueDef_out
+#if !defined (_IR_PROVIDESDEF___OUT_CH_)
+#define _IR_PROVIDESDEF___OUT_CH_
+
+class TAO_Export ProvidesDef_out
+{
+public:
+  ProvidesDef_out (ProvidesDef_ptr &);
+  ProvidesDef_out (ProvidesDef_var &);
+  ProvidesDef_out (const ProvidesDef_out &);
+  ProvidesDef_out &operator= (const ProvidesDef_out &);
+  ProvidesDef_out &operator= (const ProvidesDef_var &);
+  ProvidesDef_out &operator= (ProvidesDef_ptr);
+  operator ProvidesDef_ptr &();
+  ProvidesDef_ptr &ptr (void);
+  ProvidesDef_ptr operator-> (void);
+  
+private:
+  ProvidesDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_ValueDef_out (CORBA_ValueDef_ptr &);
-    CORBA_ValueDef_out (CORBA_ValueDef_var &);
-    CORBA_ValueDef_out (const CORBA_ValueDef_out &);
-    CORBA_ValueDef_out &operator= (const CORBA_ValueDef_out &);
-    CORBA_ValueDef_out &operator= (const CORBA_ValueDef_var &);
-    CORBA_ValueDef_out &operator= (CORBA_ValueDef_ptr);
-    operator CORBA_ValueDef_ptr &();
-    CORBA_ValueDef_ptr &ptr (void);
-    CORBA_ValueDef_ptr operator-> (void);
-
-  private:
-    CORBA_ValueDef_ptr &ptr_;
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      ProvidesDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs);
+    TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var> operator[] (CORBA::ULong index) const;
+    static ProvidesDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (ProvidesDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    ProvidesDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const ProvidesDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
-
 #endif /* end #if !defined */
 
 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDEFSEQ_CH_)
+#define _IR_PROVIDESDEFSEQ_CH_
+
+class ProvidesDefSeq;
+class ProvidesDefSeq_var;
+
+// *************************************************************
+// ProvidesDefSeq
+// *************************************************************
+
+class TAO_Export ProvidesDefSeq : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<ProvidesDef,ProvidesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ProvidesDefSeq (void); // default ctor
+  ProvidesDefSeq (CORBA::ULong max); // uses max size
+  ProvidesDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ProvidesDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  ProvidesDefSeq (const ProvidesDefSeq &); // copy ctor
+  ~ProvidesDefSeq (void);
+  static void _tao_any_destructor (void*);
 
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CH_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CH_
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ProvidesDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-    class _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+};
 
-      _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void);
-      _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_ValueDef* *value,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs);
-      virtual ~_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void);
-      _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs);
-      TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var> operator[] (CORBA::ULong index) const;
-      static CORBA_ValueDef **allocbuf (CORBA::ULong nelems);
-      static void freebuf (CORBA_ValueDef **buffer);
-      // The Base_Sequence functions, please see tao/Sequence.h
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      CORBA_ValueDef* *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_ValueDef* *get_buffer (void) const;
-      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
-      virtual void _downcast (
-          void* target,
-          CORBA_Object *src,
-          CORBA_Environment &ACE_TRY_ENV =
-            TAO_default_environment ()
-        );
-      virtual CORBA_Object* _upcast (void *src) const;
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PROVIDESDEFSEQ___VAR_CH_)
+#define _IR_PROVIDESDEFSEQ___VAR_CH_
+
+// *************************************************************
+// class IR::ProvidesDefSeq_var
+// *************************************************************
+
+class TAO_Export ProvidesDefSeq_var
+{
+public:
+  ProvidesDefSeq_var (void); // default constructor
+  ProvidesDefSeq_var (ProvidesDefSeq *);
+  ProvidesDefSeq_var (const ProvidesDefSeq_var &); // copy constructor
+  ~ProvidesDefSeq_var (void); // destructor
+  
+  ProvidesDefSeq_var &operator= (ProvidesDefSeq *);
+  ProvidesDefSeq_var &operator= (const ProvidesDefSeq_var &);
+  ProvidesDefSeq *operator-> (void);
+  const ProvidesDefSeq *operator-> (void) const;
+  
+  operator const ProvidesDefSeq &() const;
+  operator ProvidesDefSeq &();
+  operator ProvidesDefSeq &() const;
+  operator ProvidesDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<ProvidesDef, ProvidesDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ProvidesDefSeq &in (void) const;
+  ProvidesDefSeq &inout (void);
+  ProvidesDefSeq *&out (void);
+  ProvidesDefSeq *_retn (void);
+  ProvidesDefSeq *ptr (void) const;
+
+private:
+  ProvidesDefSeq *ptr_;
+};
 
-    };
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_PROVIDESDEFSEQ___OUT_CH_)
+#define _IR_PROVIDESDEFSEQ___OUT_CH_
+
+class TAO_Export ProvidesDefSeq_out
+{
+public:
+  ProvidesDefSeq_out (ProvidesDefSeq *&);
+  ProvidesDefSeq_out (ProvidesDefSeq_var &);
+  ProvidesDefSeq_out (const ProvidesDefSeq_out &);
+  ProvidesDefSeq_out &operator= (const ProvidesDefSeq_out &);
+  ProvidesDefSeq_out &operator= (ProvidesDefSeq *);
+  operator ProvidesDefSeq *&();
+  ProvidesDefSeq *&ptr (void);
+  ProvidesDefSeq *operator-> (void);
+  TAO_Object_Manager<ProvidesDef, ProvidesDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  ProvidesDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ProvidesDefSeq_var &);
+};
 
-#if !defined (_CORBA_VALUEDEFSEQ_CH_)
-#define _CORBA_VALUEDEFSEQ_CH_
 
-  // *************************************************************
-  // ValueDefSeq
-  // *************************************************************
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDefSeq;
+
+class UsesDef;
+
+#if !defined (_IR_USESDEF___PTR_CH_)
+#define _IR_USESDEF___PTR_CH_
+
+typedef UsesDef *UsesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___VAR_CH_)
+#define _IR_USESDEF___VAR_CH_
+
+class TAO_Export UsesDef_var
+{
+public:
+  UsesDef_var (void); // default constructor
+  UsesDef_var (UsesDef_ptr);
+  UsesDef_var (const UsesDef_var &); // copy constructor
+  ~UsesDef_var (void); // destructor
+  
+  UsesDef_var &operator= (UsesDef_ptr);
+  UsesDef_var &operator= (const UsesDef_var &);
+  UsesDef_ptr operator-> (void) const;
+  
+  operator const UsesDef_ptr &() const;
+  operator UsesDef_ptr &();
+  // in, inout, out, _retn 
+  UsesDef_ptr in (void) const;
+  UsesDef_ptr &inout (void);
+  UsesDef_ptr &out (void);
+  UsesDef_ptr _retn (void);
+  UsesDef_ptr ptr (void) const;
+
+private:
+  UsesDef_ptr ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___OUT_CH_)
+#define _IR_USESDEF___OUT_CH_
+
+class TAO_Export UsesDef_out
+{
+public:
+  UsesDef_out (UsesDef_ptr &);
+  UsesDef_out (UsesDef_var &);
+  UsesDef_out (const UsesDef_out &);
+  UsesDef_out &operator= (const UsesDef_out &);
+  UsesDef_out &operator= (const UsesDef_var &);
+  UsesDef_out &operator= (UsesDef_ptr);
+  operator UsesDef_ptr &();
+  UsesDef_ptr &ptr (void);
+  UsesDef_ptr operator-> (void);
+  
+private:
+  UsesDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
 
-  class TAO_Export CORBA_ValueDefSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Object_Sequence<CORBA_ValueDef,CORBA_ValueDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_ValueDefSeq (void); // default ctor
-    CORBA_ValueDefSeq (CORBA::ULong max); // uses max size
-    CORBA_ValueDefSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      CORBA_ValueDef_ptr *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_ValueDefSeq (const CORBA_ValueDefSeq &); // copy ctor
-    ~CORBA_ValueDefSeq (void); // dtor
-
-    static void _tao_any_destructor (void *x);
+      UsesDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs);
+    TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var> operator[] (CORBA::ULong index) const;
+    static UsesDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (UsesDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    UsesDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const UsesDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEDEFSEQ___VAR_CH_)
-#define _CORBA_VALUEDEFSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_USESDEFSEQ_CH_)
+#define _IR_USESDEFSEQ_CH_
+
+class UsesDefSeq;
+class UsesDefSeq_var;
 
 // *************************************************************
-  // class CORBA::ValueDefSeq_var
-  // *************************************************************
+// UsesDefSeq
+// *************************************************************
 
-  class TAO_Export CORBA_ValueDefSeq_var
-  {
-  public:
-    CORBA_ValueDefSeq_var (void); // default constructor
-    CORBA_ValueDefSeq_var (CORBA_ValueDefSeq *);
-    CORBA_ValueDefSeq_var (const CORBA_ValueDefSeq_var &); // copy constructor
-    ~CORBA_ValueDefSeq_var (void); // destructor
-
-    CORBA_ValueDefSeq_var &operator= (CORBA_ValueDefSeq *);
-    CORBA_ValueDefSeq_var &operator= (const CORBA_ValueDefSeq_var &);
-    CORBA_ValueDefSeq *operator-> (void);
-    const CORBA_ValueDefSeq *operator-> (void) const;
-
-    operator const CORBA_ValueDefSeq &() const;
-    operator CORBA_ValueDefSeq &();
-    operator CORBA_ValueDefSeq &() const;
-    TAO_Object_Manager<CORBA_ValueDef,CORBA_ValueDef_var> operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_ValueDefSeq &in (void) const;
-    CORBA_ValueDefSeq &inout (void);
-    CORBA_ValueDefSeq *&out (void);
-    CORBA_ValueDefSeq *_retn (void);
-    CORBA_ValueDefSeq *ptr (void) const;
+class TAO_Export UsesDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<UsesDef,UsesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  UsesDefSeq (void); // default ctor
+  UsesDefSeq (CORBA::ULong max); // uses max size
+  UsesDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    UsesDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  UsesDefSeq (const UsesDefSeq &); // copy ctor
+  ~UsesDefSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_ValueDefSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UsesDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEDEFSEQ___OUT_CH_)
-#define _CORBA_VALUEDEFSEQ___OUT_CH_
+#if !defined (_IR_USESDEFSEQ___VAR_CH_)
+#define _IR_USESDEFSEQ___VAR_CH_
 
-  class TAO_Export CORBA_ValueDefSeq_out
-  {
-  public:
-    CORBA_ValueDefSeq_out (CORBA_ValueDefSeq *&);
-    CORBA_ValueDefSeq_out (CORBA_ValueDefSeq_var &);
-    CORBA_ValueDefSeq_out (const CORBA_ValueDefSeq_out &);
-    CORBA_ValueDefSeq_out &operator= (const CORBA_ValueDefSeq_out &);
-    CORBA_ValueDefSeq_out &operator= (CORBA_ValueDefSeq *);
-    operator CORBA_ValueDefSeq *&();
-    CORBA_ValueDefSeq *&ptr (void);
-    CORBA_ValueDefSeq *operator-> (void);
-    TAO_Object_Manager<CORBA_ValueDef,CORBA_ValueDef_var> operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::UsesDefSeq_var
+// *************************************************************
 
-  private:
-    CORBA_ValueDefSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ValueDefSeq_var &);
-  };
+class TAO_Export UsesDefSeq_var
+{
+public:
+  UsesDefSeq_var (void); // default constructor
+  UsesDefSeq_var (UsesDefSeq *);
+  UsesDefSeq_var (const UsesDefSeq_var &); // copy constructor
+  ~UsesDefSeq_var (void); // destructor
+  
+  UsesDefSeq_var &operator= (UsesDefSeq *);
+  UsesDefSeq_var &operator= (const UsesDefSeq_var &);
+  UsesDefSeq *operator-> (void);
+  const UsesDefSeq *operator-> (void) const;
+  
+  operator const UsesDefSeq &() const;
+  operator UsesDefSeq &();
+  operator UsesDefSeq &() const;
+  operator UsesDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<UsesDef, UsesDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const UsesDefSeq &in (void) const;
+  UsesDefSeq &inout (void);
+  UsesDefSeq *&out (void);
+  UsesDefSeq *_retn (void);
+  UsesDefSeq *ptr (void) const;
+
+private:
+  UsesDefSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_VALUEBOXDEF___VAR_CH_)
-#define _CORBA_VALUEBOXDEF___VAR_CH_
 
-  class TAO_Export CORBA_ValueBoxDef_var
-  {
-  public:
-    CORBA_ValueBoxDef_var (void); // default constructor
-    CORBA_ValueBoxDef_var (CORBA_ValueBoxDef_ptr);
-    CORBA_ValueBoxDef_var (const CORBA_ValueBoxDef_var &); // copy constructor
-    ~CORBA_ValueBoxDef_var (void); // destructor
+#if !defined (_IR_USESDEFSEQ___OUT_CH_)
+#define _IR_USESDEFSEQ___OUT_CH_
+
+class TAO_Export UsesDefSeq_out
+{
+public:
+  UsesDefSeq_out (UsesDefSeq *&);
+  UsesDefSeq_out (UsesDefSeq_var &);
+  UsesDefSeq_out (const UsesDefSeq_out &);
+  UsesDefSeq_out &operator= (const UsesDefSeq_out &);
+  UsesDefSeq_out &operator= (UsesDefSeq *);
+  operator UsesDefSeq *&();
+  UsesDefSeq *&ptr (void);
+  UsesDefSeq *operator-> (void);
+  TAO_Object_Manager<UsesDef, UsesDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  UsesDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const UsesDefSeq_var &);
+};
 
-    CORBA_ValueBoxDef_var &operator= (CORBA_ValueBoxDef_ptr);
-    CORBA_ValueBoxDef_var &operator= (const CORBA_ValueBoxDef_var &);
-    CORBA_ValueBoxDef_ptr operator-> (void) const;
 
-    operator const CORBA_ValueBoxDef_ptr &() const;
-    operator CORBA_ValueBoxDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ValueBoxDef_ptr in (void) const;
-    CORBA_ValueBoxDef_ptr &inout (void);
-    CORBA_ValueBoxDef_ptr &out (void);
-    CORBA_ValueBoxDef_ptr _retn (void);
-    CORBA_ValueBoxDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_ValueBoxDef_ptr ptr_;
-  };
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDefSeq;
+
+class HomeDef;
+
+#if !defined (_IR_HOMEDEF___PTR_CH_)
+#define _IR_HOMEDEF___PTR_CH_
 
+typedef HomeDef *HomeDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEBOXDEF___OUT_CH_)
-#define _CORBA_VALUEBOXDEF___OUT_CH_
+#if !defined (_IR_HOMEDEF___VAR_CH_)
+#define _IR_HOMEDEF___VAR_CH_
+
+class TAO_Export HomeDef_var
+{
+public:
+  HomeDef_var (void); // default constructor
+  HomeDef_var (HomeDef_ptr);
+  HomeDef_var (const HomeDef_var &); // copy constructor
+  ~HomeDef_var (void); // destructor
+  
+  HomeDef_var &operator= (HomeDef_ptr);
+  HomeDef_var &operator= (const HomeDef_var &);
+  HomeDef_ptr operator-> (void) const;
+  
+  operator const HomeDef_ptr &() const;
+  operator HomeDef_ptr &();
+  // in, inout, out, _retn 
+  HomeDef_ptr in (void) const;
+  HomeDef_ptr &inout (void);
+  HomeDef_ptr &out (void);
+  HomeDef_ptr _retn (void);
+  HomeDef_ptr ptr (void) const;
+
+private:
+  HomeDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_ValueBoxDef_out
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF___OUT_CH_)
+#define _IR_HOMEDEF___OUT_CH_
+
+class TAO_Export HomeDef_out
+{
+public:
+  HomeDef_out (HomeDef_ptr &);
+  HomeDef_out (HomeDef_var &);
+  HomeDef_out (const HomeDef_out &);
+  HomeDef_out &operator= (const HomeDef_out &);
+  HomeDef_out &operator= (const HomeDef_var &);
+  HomeDef_out &operator= (HomeDef_ptr);
+  operator HomeDef_ptr &();
+  HomeDef_ptr &ptr (void);
+  HomeDef_ptr operator-> (void);
+  
+private:
+  HomeDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_ptr &);
-    CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_var &);
-    CORBA_ValueBoxDef_out (const CORBA_ValueBoxDef_out &);
-    CORBA_ValueBoxDef_out &operator= (const CORBA_ValueBoxDef_out &);
-    CORBA_ValueBoxDef_out &operator= (const CORBA_ValueBoxDef_var &);
-    CORBA_ValueBoxDef_out &operator= (CORBA_ValueBoxDef_ptr);
-    operator CORBA_ValueBoxDef_ptr &();
-    CORBA_ValueBoxDef_ptr &ptr (void);
-    CORBA_ValueBoxDef_ptr operator-> (void);
-
-  private:
-    CORBA_ValueBoxDef_ptr &ptr_;
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      HomeDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq(const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs);
+    TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var> operator[] (CORBA::ULong index) const;
+    static HomeDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (HomeDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    HomeDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const HomeDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
-
 #endif /* end #if !defined */
 
 
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_HOMEDEFSEQ_CH_)
+#define _IR_HOMEDEFSEQ_CH_
+
+class HomeDefSeq;
+class HomeDefSeq_var;
+
+// *************************************************************
+// HomeDefSeq
+// *************************************************************
+
+class TAO_Export HomeDefSeq : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<HomeDef,HomeDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  HomeDefSeq (void); // default ctor
+  HomeDefSeq (CORBA::ULong max); // uses max size
+  HomeDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    HomeDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  HomeDefSeq (const HomeDefSeq &); // copy ctor
+  ~HomeDefSeq (void);
+  static void _tao_any_destructor (void*);
 
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CH_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CH_
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef HomeDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-    class _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+};
 
-      _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void);
-      _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_Contained* *value,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs);
-      virtual ~_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void);
-      _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs);
-      TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> operator[] (CORBA::ULong index) const;
-      static CORBA_Contained **allocbuf (CORBA::ULong nelems);
-      static void freebuf (CORBA_Contained **buffer);
-      // The Base_Sequence functions, please see tao/Sequence.h
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      CORBA_Contained* *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_Contained* *get_buffer (void) const;
-      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
-      virtual void _downcast (
-          void* target,
-          CORBA_Object *src,
-          CORBA_Environment &ACE_TRY_ENV =
-            TAO_default_environment ()
-        );
-      virtual CORBA_Object* _upcast (void *src) const;
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEFSEQ___VAR_CH_)
+#define _IR_HOMEDEFSEQ___VAR_CH_
+
+// *************************************************************
+// class IR::HomeDefSeq_var
+// *************************************************************
+
+class TAO_Export HomeDefSeq_var
+{
+public:
+  HomeDefSeq_var (void); // default constructor
+  HomeDefSeq_var (HomeDefSeq *);
+  HomeDefSeq_var (const HomeDefSeq_var &); // copy constructor
+  ~HomeDefSeq_var (void); // destructor
+  
+  HomeDefSeq_var &operator= (HomeDefSeq *);
+  HomeDefSeq_var &operator= (const HomeDefSeq_var &);
+  HomeDefSeq *operator-> (void);
+  const HomeDefSeq *operator-> (void) const;
+  
+  operator const HomeDefSeq &() const;
+  operator HomeDefSeq &();
+  operator HomeDefSeq &() const;
+  operator HomeDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<HomeDef, HomeDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const HomeDefSeq &in (void) const;
+  HomeDefSeq &inout (void);
+  HomeDefSeq *&out (void);
+  HomeDefSeq *_retn (void);
+  HomeDefSeq *ptr (void) const;
+
+private:
+  HomeDefSeq *ptr_;
+};
 
-    };
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_HOMEDEFSEQ___OUT_CH_)
+#define _IR_HOMEDEFSEQ___OUT_CH_
+
+class TAO_Export HomeDefSeq_out
+{
+public:
+  HomeDefSeq_out (HomeDefSeq *&);
+  HomeDefSeq_out (HomeDefSeq_var &);
+  HomeDefSeq_out (const HomeDefSeq_out &);
+  HomeDefSeq_out &operator= (const HomeDefSeq_out &);
+  HomeDefSeq_out &operator= (HomeDefSeq *);
+  operator HomeDefSeq *&();
+  HomeDefSeq *&ptr (void);
+  HomeDefSeq *operator-> (void);
+  TAO_Object_Manager<HomeDef, HomeDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  HomeDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const HomeDefSeq_var &);
+};
 
-#if !defined (_CORBA_CONTAINEDSEQ_CH_)
-#define _CORBA_CONTAINEDSEQ_CH_
 
-  // *************************************************************
-  // ContainedSeq
-  // *************************************************************
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDefSeq;
+
+class EventDef;
+
+#if !defined (_IR_EVENTDEF___PTR_CH_)
+#define _IR_EVENTDEF___PTR_CH_
+
+typedef EventDef *EventDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EVENTDEF___VAR_CH_)
+#define _IR_EVENTDEF___VAR_CH_
+
+class TAO_Export EventDef_var
+{
+public:
+  EventDef_var (void); // default constructor
+  EventDef_var (EventDef_ptr);
+  EventDef_var (const EventDef_var &); // copy constructor
+  ~EventDef_var (void); // destructor
+  
+  EventDef_var &operator= (EventDef_ptr);
+  EventDef_var &operator= (const EventDef_var &);
+  EventDef_ptr operator-> (void) const;
+  
+  operator const EventDef_ptr &() const;
+  operator EventDef_ptr &();
+  // in, inout, out, _retn 
+  EventDef_ptr in (void) const;
+  EventDef_ptr &inout (void);
+  EventDef_ptr &out (void);
+  EventDef_ptr _retn (void);
+  EventDef_ptr ptr (void) const;
+
+private:
+  EventDef_ptr ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EVENTDEF___OUT_CH_)
+#define _IR_EVENTDEF___OUT_CH_
+
+class TAO_Export EventDef_out
+{
+public:
+  EventDef_out (EventDef_ptr &);
+  EventDef_out (EventDef_var &);
+  EventDef_out (const EventDef_out &);
+  EventDef_out &operator= (const EventDef_out &);
+  EventDef_out &operator= (const EventDef_var &);
+  EventDef_out &operator= (EventDef_ptr);
+  operator EventDef_ptr &();
+  EventDef_ptr &ptr (void);
+  EventDef_ptr operator-> (void);
+  
+private:
+  EventDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+class EmitsDef;
+
+#if !defined (_IR_EMITSDEF___PTR_CH_)
+#define _IR_EMITSDEF___PTR_CH_
+
+typedef EmitsDef *EmitsDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEF___VAR_CH_)
+#define _IR_EMITSDEF___VAR_CH_
+
+class TAO_Export EmitsDef_var
+{
+public:
+  EmitsDef_var (void); // default constructor
+  EmitsDef_var (EmitsDef_ptr);
+  EmitsDef_var (const EmitsDef_var &); // copy constructor
+  ~EmitsDef_var (void); // destructor
+  
+  EmitsDef_var &operator= (EmitsDef_ptr);
+  EmitsDef_var &operator= (const EmitsDef_var &);
+  EmitsDef_ptr operator-> (void) const;
+  
+  operator const EmitsDef_ptr &() const;
+  operator EmitsDef_ptr &();
+  // in, inout, out, _retn 
+  EmitsDef_ptr in (void) const;
+  EmitsDef_ptr &inout (void);
+  EmitsDef_ptr &out (void);
+  EmitsDef_ptr _retn (void);
+  EmitsDef_ptr ptr (void) const;
+
+private:
+  EmitsDef_ptr ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEF___OUT_CH_)
+#define _IR_EMITSDEF___OUT_CH_
+
+class TAO_Export EmitsDef_out
+{
+public:
+  EmitsDef_out (EmitsDef_ptr &);
+  EmitsDef_out (EmitsDef_var &);
+  EmitsDef_out (const EmitsDef_out &);
+  EmitsDef_out &operator= (const EmitsDef_out &);
+  EmitsDef_out &operator= (const EmitsDef_var &);
+  EmitsDef_out &operator= (EmitsDef_ptr);
+  operator EmitsDef_ptr &();
+  EmitsDef_ptr &ptr (void);
+  EmitsDef_ptr operator-> (void);
+  
+private:
+  EmitsDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
 
-  class TAO_Export CORBA_ContainedSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Object_Sequence<CORBA_Contained,CORBA_Contained_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_ContainedSeq (void); // default ctor
-    CORBA_ContainedSeq (CORBA::ULong max); // uses max size
-    CORBA_ContainedSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      CORBA_Contained_ptr *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_ContainedSeq (const CORBA_ContainedSeq &); // copy ctor
-    ~CORBA_ContainedSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      EmitsDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq(const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs);
+    TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var> operator[] (CORBA::ULong index) const;
+    static EmitsDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (EmitsDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    EmitsDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const EmitsDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINEDSEQ___VAR_CH_)
-#define _CORBA_CONTAINEDSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EMITSDEFSEQ_CH_)
+#define _IR_EMITSDEFSEQ_CH_
+
+class EmitsDefSeq;
+class EmitsDefSeq_var;
 
 // *************************************************************
-  // class CORBA::ContainedSeq_var
-  // *************************************************************
+// EmitsDefSeq
+// *************************************************************
 
-  class TAO_Export CORBA_ContainedSeq_var
-  {
-  public:
-    CORBA_ContainedSeq_var (void); // default constructor
-    CORBA_ContainedSeq_var (CORBA_ContainedSeq *);
-    CORBA_ContainedSeq_var (const CORBA_ContainedSeq_var &); // copy constructor
-    ~CORBA_ContainedSeq_var (void); // destructor
-
-    CORBA_ContainedSeq_var &operator= (CORBA_ContainedSeq *);
-    CORBA_ContainedSeq_var &operator= (const CORBA_ContainedSeq_var &);
-    CORBA_ContainedSeq *operator-> (void);
-    const CORBA_ContainedSeq *operator-> (void) const;
-
-    operator const CORBA_ContainedSeq &() const;
-    operator CORBA_ContainedSeq &();
-    operator CORBA_ContainedSeq &() const;
-    TAO_Object_Manager<CORBA_Contained,CORBA_Contained_var> operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_ContainedSeq &in (void) const;
-    CORBA_ContainedSeq &inout (void);
-    CORBA_ContainedSeq *&out (void);
-    CORBA_ContainedSeq *_retn (void);
-    CORBA_ContainedSeq *ptr (void) const;
+class TAO_Export EmitsDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<EmitsDef,EmitsDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  EmitsDefSeq (void); // default ctor
+  EmitsDefSeq (CORBA::ULong max); // uses max size
+  EmitsDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    EmitsDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  EmitsDefSeq (const EmitsDefSeq &); // copy ctor
+  ~EmitsDefSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_ContainedSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef EmitsDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINEDSEQ___OUT_CH_)
-#define _CORBA_CONTAINEDSEQ___OUT_CH_
+#if !defined (_IR_EMITSDEFSEQ___VAR_CH_)
+#define _IR_EMITSDEFSEQ___VAR_CH_
 
-  class  CORBA_ContainedSeq_out
-  {
-  public:
-    CORBA_ContainedSeq_out (CORBA_ContainedSeq *&);
-    CORBA_ContainedSeq_out (CORBA_ContainedSeq_var &);
-    CORBA_ContainedSeq_out (const CORBA_ContainedSeq_out &);
-    CORBA_ContainedSeq_out &operator= (const CORBA_ContainedSeq_out &);
-    CORBA_ContainedSeq_out &operator= (CORBA_ContainedSeq *);
-    operator CORBA_ContainedSeq *&();
-    CORBA_ContainedSeq *&ptr (void);
-    CORBA_ContainedSeq *operator-> (void);
-    TAO_Object_Manager<CORBA_Contained,CORBA_Contained_var> operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::EmitsDefSeq_var
+// *************************************************************
 
-  private:
-    CORBA_ContainedSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ContainedSeq_var &);
-  };
+class TAO_Export EmitsDefSeq_var
+{
+public:
+  EmitsDefSeq_var (void); // default constructor
+  EmitsDefSeq_var (EmitsDefSeq *);
+  EmitsDefSeq_var (const EmitsDefSeq_var &); // copy constructor
+  ~EmitsDefSeq_var (void); // destructor
+  
+  EmitsDefSeq_var &operator= (EmitsDefSeq *);
+  EmitsDefSeq_var &operator= (const EmitsDefSeq_var &);
+  EmitsDefSeq *operator-> (void);
+  const EmitsDefSeq *operator-> (void) const;
+  
+  operator const EmitsDefSeq &() const;
+  operator EmitsDefSeq &();
+  operator EmitsDefSeq &() const;
+  operator EmitsDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<EmitsDef, EmitsDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const EmitsDefSeq &in (void) const;
+  EmitsDefSeq &inout (void);
+  EmitsDefSeq *&out (void);
+  EmitsDefSeq *_retn (void);
+  EmitsDefSeq *ptr (void) const;
+
+private:
+  EmitsDefSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-  struct  CORBA_StructMember
-  {
-    static void _tao_any_destructor (void*);
 
-    TAO_String_Manager name;
-    CORBA::TypeCode_var type;
-    TAO_Object_Field_T<CORBA_IDLType,CORBA_IDLType_var> type_def;
-  };
+#if !defined (_IR_EMITSDEFSEQ___OUT_CH_)
+#define _IR_EMITSDEFSEQ___OUT_CH_
+
+class TAO_Export EmitsDefSeq_out
+{
+public:
+  EmitsDefSeq_out (EmitsDefSeq *&);
+  EmitsDefSeq_out (EmitsDefSeq_var &);
+  EmitsDefSeq_out (const EmitsDefSeq_out &);
+  EmitsDefSeq_out &operator= (const EmitsDefSeq_out &);
+  EmitsDefSeq_out &operator= (EmitsDefSeq *);
+  operator EmitsDefSeq *&();
+  EmitsDefSeq *&ptr (void);
+  EmitsDefSeq *operator-> (void);
+  TAO_Object_Manager<EmitsDef, EmitsDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  EmitsDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const EmitsDefSeq_var &);
+};
 
-  class TAO_Export CORBA_StructMember_var
-  {
-  public:
-    CORBA_StructMember_var (void); // default constructor
-    CORBA_StructMember_var (CORBA_StructMember *);
-    CORBA_StructMember_var (const CORBA_StructMember_var &); // copy constructor
-    ~CORBA_StructMember_var (void); // destructor
-
-    CORBA_StructMember_var &operator= (CORBA_StructMember *);
-    CORBA_StructMember_var &operator= (const CORBA_StructMember_var &);
-    CORBA_StructMember *operator-> (void);
-    const CORBA_StructMember *operator-> (void) const;
-
-    operator const CORBA_StructMember &() const;
-    operator CORBA_StructMember &();
-    operator CORBA_StructMember &() const;
-    // in, inout, out, _retn
-    const CORBA_StructMember &in (void) const;
-    CORBA_StructMember &inout (void);
-    CORBA_StructMember *&out (void);
-    CORBA_StructMember *_retn (void);
-    CORBA_StructMember *ptr (void) const;
 
-  private:
-    CORBA_StructMember *ptr_;
-  };
+#endif /* end #if !defined */
 
-  class TAO_Export CORBA_StructMember_out
-  {
-  public:
-    CORBA_StructMember_out (CORBA_StructMember *&);
-    CORBA_StructMember_out (CORBA_StructMember_var &);
-    CORBA_StructMember_out (const CORBA_StructMember_out &);
-    CORBA_StructMember_out &operator= (const CORBA_StructMember_out &);
-    CORBA_StructMember_out &operator= (CORBA_StructMember *);
-    operator CORBA_StructMember *&();
-    CORBA_StructMember *&ptr (void);
-    CORBA_StructMember *operator-> (void);
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EmitsDefSeq;
 
-  private:
-    CORBA_StructMember *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_StructMember_var &);
-  };
+class PublishesDef;
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+#if !defined (_IR_PUBLISHESDEF___PTR_CH_)
+#define _IR_PUBLISHESDEF___PTR_CH_
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CH_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CH_
+typedef PublishesDef *PublishesDef_ptr;
 
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_StructMemberSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+#endif /* end #if !defined */
 
-      _TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void); // Default constructor.
-      _TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_StructMember *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_CORBA_StructMemberSeq (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs);
-      _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs);
-      virtual ~_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void); // Dtor.
-      // = Accessors.
-      CORBA_StructMember &operator[] (CORBA::ULong i);
-      const CORBA_StructMember &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static CORBA_StructMember *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA_StructMember *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
 
-      CORBA_StructMember *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_StructMember *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        CORBA_StructMember *data,
-        CORBA::Boolean release);
-    };
+#if !defined (_IR_PUBLISHESDEF___VAR_CH_)
+#define _IR_PUBLISHESDEF___VAR_CH_
+
+class TAO_Export PublishesDef_var
+{
+public:
+  PublishesDef_var (void); // default constructor
+  PublishesDef_var (PublishesDef_ptr);
+  PublishesDef_var (const PublishesDef_var &); // copy constructor
+  ~PublishesDef_var (void); // destructor
+  
+  PublishesDef_var &operator= (PublishesDef_ptr);
+  PublishesDef_var &operator= (const PublishesDef_var &);
+  PublishesDef_ptr operator-> (void) const;
+  
+  operator const PublishesDef_ptr &() const;
+  operator PublishesDef_ptr &();
+  // in, inout, out, _retn 
+  PublishesDef_ptr in (void) const;
+  PublishesDef_ptr &inout (void);
+  PublishesDef_ptr &out (void);
+  PublishesDef_ptr _retn (void);
+  PublishesDef_ptr ptr (void) const;
+
+private:
+  PublishesDef_ptr ptr_;
+};
+
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_PUBLISHESDEF___OUT_CH_)
+#define _IR_PUBLISHESDEF___OUT_CH_
 
-#if !defined (_CORBA_STRUCTMEMBERSEQ_CH_)
-#define _CORBA_STRUCTMEMBERSEQ_CH_
+class TAO_Export PublishesDef_out
+{
+public:
+  PublishesDef_out (PublishesDef_ptr &);
+  PublishesDef_out (PublishesDef_var &);
+  PublishesDef_out (const PublishesDef_out &);
+  PublishesDef_out &operator= (const PublishesDef_out &);
+  PublishesDef_out &operator= (const PublishesDef_var &);
+  PublishesDef_out &operator= (PublishesDef_ptr);
+  operator PublishesDef_ptr &();
+  PublishesDef_ptr &ptr (void);
+  PublishesDef_ptr operator-> (void);
+  
+private:
+  PublishesDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
 
-  // *************************************************************
-  // StructMemberSeq
-  // *************************************************************
 
-  class TAO_Export CORBA_StructMemberSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_CORBA_StructMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA_StructMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_StructMemberSeq (void); // default ctor
-    CORBA_StructMemberSeq (CORBA::ULong max); // uses max size
-    CORBA_StructMemberSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      CORBA_StructMember *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_StructMemberSeq (const CORBA_StructMemberSeq &); // copy ctor
-    ~CORBA_StructMemberSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      PublishesDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs);
+    TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var> operator[] (CORBA::ULong index) const;
+    static PublishesDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (PublishesDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    PublishesDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const PublishesDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRUCTMEMBERSEQ___VAR_CH_)
-#define _CORBA_STRUCTMEMBERSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PUBLISHESDEFSEQ_CH_)
+#define _IR_PUBLISHESDEFSEQ_CH_
+
+class PublishesDefSeq;
+class PublishesDefSeq_var;
 
 // *************************************************************
-  // class CORBA::StructMemberSeq_var
-  // *************************************************************
+// PublishesDefSeq
+// *************************************************************
 
-  class TAO_Export CORBA_StructMemberSeq_var
-  {
-  public:
-    CORBA_StructMemberSeq_var (void); // default constructor
-    CORBA_StructMemberSeq_var (CORBA_StructMemberSeq *);
-    CORBA_StructMemberSeq_var (const CORBA_StructMemberSeq_var &); // copy constructor
-    ~CORBA_StructMemberSeq_var (void); // destructor
-
-    CORBA_StructMemberSeq_var &operator= (CORBA_StructMemberSeq *);
-    CORBA_StructMemberSeq_var &operator= (const CORBA_StructMemberSeq_var &);
-    CORBA_StructMemberSeq *operator-> (void);
-    const CORBA_StructMemberSeq *operator-> (void) const;
-
-    operator const CORBA_StructMemberSeq &() const;
-    operator CORBA_StructMemberSeq &();
-    operator CORBA_StructMemberSeq &() const;
-    CORBA_StructMember &operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_StructMemberSeq &in (void) const;
-    CORBA_StructMemberSeq &inout (void);
-    CORBA_StructMemberSeq *&out (void);
-    CORBA_StructMemberSeq *_retn (void);
-    CORBA_StructMemberSeq *ptr (void) const;
+class TAO_Export PublishesDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<PublishesDef,PublishesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  PublishesDefSeq (void); // default ctor
+  PublishesDefSeq (CORBA::ULong max); // uses max size
+  PublishesDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    PublishesDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  PublishesDefSeq (const PublishesDefSeq &); // copy ctor
+  ~PublishesDefSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_StructMemberSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef PublishesDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRUCTMEMBERSEQ___OUT_CH_)
-#define _CORBA_STRUCTMEMBERSEQ___OUT_CH_
+#if !defined (_IR_PUBLISHESDEFSEQ___VAR_CH_)
+#define _IR_PUBLISHESDEFSEQ___VAR_CH_
 
-  class TAO_Export CORBA_StructMemberSeq_out
-  {
-  public:
-    CORBA_StructMemberSeq_out (CORBA_StructMemberSeq *&);
-    CORBA_StructMemberSeq_out (CORBA_StructMemberSeq_var &);
-    CORBA_StructMemberSeq_out (const CORBA_StructMemberSeq_out &);
-    CORBA_StructMemberSeq_out &operator= (const CORBA_StructMemberSeq_out &);
-    CORBA_StructMemberSeq_out &operator= (CORBA_StructMemberSeq *);
-    operator CORBA_StructMemberSeq *&();
-    CORBA_StructMemberSeq *&ptr (void);
-    CORBA_StructMemberSeq *operator-> (void);
-    CORBA_StructMember &operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::PublishesDefSeq_var
+// *************************************************************
 
-  private:
-    CORBA_StructMemberSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_StructMemberSeq_var &);
-  };
+class TAO_Export PublishesDefSeq_var
+{
+public:
+  PublishesDefSeq_var (void); // default constructor
+  PublishesDefSeq_var (PublishesDefSeq *);
+  PublishesDefSeq_var (const PublishesDefSeq_var &); // copy constructor
+  ~PublishesDefSeq_var (void); // destructor
+  
+  PublishesDefSeq_var &operator= (PublishesDefSeq *);
+  PublishesDefSeq_var &operator= (const PublishesDefSeq_var &);
+  PublishesDefSeq *operator-> (void);
+  const PublishesDefSeq *operator-> (void) const;
+  
+  operator const PublishesDefSeq &() const;
+  operator PublishesDefSeq &();
+  operator PublishesDefSeq &() const;
+  operator PublishesDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<PublishesDef, PublishesDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const PublishesDefSeq &in (void) const;
+  PublishesDefSeq &inout (void);
+  PublishesDefSeq *&out (void);
+  PublishesDefSeq *_retn (void);
+  PublishesDefSeq *ptr (void) const;
+
+private:
+  PublishesDefSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-  struct  CORBA_Initializer
-  {
-    static void _tao_any_destructor (void*);
 
-    CORBA_StructMemberSeq members;
-  };
+#if !defined (_IR_PUBLISHESDEFSEQ___OUT_CH_)
+#define _IR_PUBLISHESDEFSEQ___OUT_CH_
+
+class TAO_Export PublishesDefSeq_out
+{
+public:
+  PublishesDefSeq_out (PublishesDefSeq *&);
+  PublishesDefSeq_out (PublishesDefSeq_var &);
+  PublishesDefSeq_out (const PublishesDefSeq_out &);
+  PublishesDefSeq_out &operator= (const PublishesDefSeq_out &);
+  PublishesDefSeq_out &operator= (PublishesDefSeq *);
+  operator PublishesDefSeq *&();
+  PublishesDefSeq *&ptr (void);
+  PublishesDefSeq *operator-> (void);
+  TAO_Object_Manager<PublishesDef, PublishesDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  PublishesDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const PublishesDefSeq_var &);
+};
 
-  class TAO_Export CORBA_Initializer_var
-  {
-  public:
-    CORBA_Initializer_var (void); // default constructor
-    CORBA_Initializer_var (CORBA_Initializer *);
-    CORBA_Initializer_var (const CORBA_Initializer_var &); // copy constructor
-    ~CORBA_Initializer_var (void); // destructor
-
-    CORBA_Initializer_var &operator= (CORBA_Initializer *);
-    CORBA_Initializer_var &operator= (const CORBA_Initializer_var &);
-    CORBA_Initializer *operator-> (void);
-    const CORBA_Initializer *operator-> (void) const;
-
-    operator const CORBA_Initializer &() const;
-    operator CORBA_Initializer &();
-    operator CORBA_Initializer &() const;
-    // in, inout, out, _retn
-    const CORBA_Initializer &in (void) const;
-    CORBA_Initializer &inout (void);
-    CORBA_Initializer *&out (void);
-    CORBA_Initializer *_retn (void);
-    CORBA_Initializer *ptr (void) const;
 
-  private:
-    CORBA_Initializer *ptr_;
-  };
+#endif /* end #if !defined */
 
-  class TAO_Export CORBA_Initializer_out
-  {
-  public:
-    CORBA_Initializer_out (CORBA_Initializer *&);
-    CORBA_Initializer_out (CORBA_Initializer_var &);
-    CORBA_Initializer_out (const CORBA_Initializer_out &);
-    CORBA_Initializer_out &operator= (const CORBA_Initializer_out &);
-    CORBA_Initializer_out &operator= (CORBA_Initializer *);
-    operator CORBA_Initializer *&();
-    CORBA_Initializer *&ptr (void);
-    CORBA_Initializer *operator-> (void);
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PublishesDefSeq;
 
-  private:
-    CORBA_Initializer *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_Initializer_var &);
-  };
+class ConsumesDef;
 
+#if !defined (_IR_CONSUMESDEF___PTR_CH_)
+#define _IR_CONSUMESDEF___PTR_CH_
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+typedef ConsumesDef *ConsumesDef_ptr;
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CH_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CH_
+#endif /* end #if !defined */
 
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_InitializerSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
 
-      _TAO_Unbounded_Sequence_CORBA_InitializerSeq (void); // Default constructor.
-      _TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_Initializer *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_CORBA_InitializerSeq (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs);
-      _TAO_Unbounded_Sequence_CORBA_InitializerSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs);
-      virtual ~_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void); // Dtor.
-      // = Accessors.
-      CORBA_Initializer &operator[] (CORBA::ULong i);
-      const CORBA_Initializer &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static CORBA_Initializer *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA_Initializer *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+#if !defined (_IR_CONSUMESDEF___VAR_CH_)
+#define _IR_CONSUMESDEF___VAR_CH_
+
+class TAO_Export ConsumesDef_var
+{
+public:
+  ConsumesDef_var (void); // default constructor
+  ConsumesDef_var (ConsumesDef_ptr);
+  ConsumesDef_var (const ConsumesDef_var &); // copy constructor
+  ~ConsumesDef_var (void); // destructor
+  
+  ConsumesDef_var &operator= (ConsumesDef_ptr);
+  ConsumesDef_var &operator= (const ConsumesDef_var &);
+  ConsumesDef_ptr operator-> (void) const;
+  
+  operator const ConsumesDef_ptr &() const;
+  operator ConsumesDef_ptr &();
+  // in, inout, out, _retn 
+  ConsumesDef_ptr in (void) const;
+  ConsumesDef_ptr &inout (void);
+  ConsumesDef_ptr &out (void);
+  ConsumesDef_ptr _retn (void);
+  ConsumesDef_ptr ptr (void) const;
+
+private:
+  ConsumesDef_ptr ptr_;
+};
 
-      CORBA_Initializer *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_Initializer *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        CORBA_Initializer *data,
-        CORBA::Boolean release);
-    };
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_CONSUMESDEF___OUT_CH_)
+#define _IR_CONSUMESDEF___OUT_CH_
 
-#if !defined (_CORBA_INITIALIZERSEQ_CH_)
-#define _CORBA_INITIALIZERSEQ_CH_
+class TAO_Export ConsumesDef_out
+{
+public:
+  ConsumesDef_out (ConsumesDef_ptr &);
+  ConsumesDef_out (ConsumesDef_var &);
+  ConsumesDef_out (const ConsumesDef_out &);
+  ConsumesDef_out &operator= (const ConsumesDef_out &);
+  ConsumesDef_out &operator= (const ConsumesDef_var &);
+  ConsumesDef_out &operator= (ConsumesDef_ptr);
+  operator ConsumesDef_ptr &();
+  ConsumesDef_ptr &ptr (void);
+  ConsumesDef_ptr operator-> (void);
+  
+private:
+  ConsumesDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
 
-  // *************************************************************
-  // InitializerSeq
-  // *************************************************************
 
-  class TAO_Export CORBA_InitializerSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_CORBA_InitializerSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA_Initializer>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_InitializerSeq (void); // default ctor
-    CORBA_InitializerSeq (CORBA::ULong max); // uses max size
-    CORBA_InitializerSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      CORBA_Initializer *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_InitializerSeq (const CORBA_InitializerSeq &); // copy ctor
-    ~CORBA_InitializerSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      ConsumesDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs);
+    TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var> operator[] (CORBA::ULong index) const;
+    static ConsumesDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (ConsumesDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    ConsumesDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const ConsumesDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_INITIALIZERSEQ___VAR_CH_)
-#define _CORBA_INITIALIZERSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_CONSUMESDEFSEQ_CH_)
+#define _IR_CONSUMESDEFSEQ_CH_
+
+class ConsumesDefSeq;
+class ConsumesDefSeq_var;
 
 // *************************************************************
-  // class CORBA::InitializerSeq_var
-  // *************************************************************
+// ConsumesDefSeq
+// *************************************************************
 
-  class TAO_Export CORBA_InitializerSeq_var
-  {
-  public:
-    CORBA_InitializerSeq_var (void); // default constructor
-    CORBA_InitializerSeq_var (CORBA_InitializerSeq *);
-    CORBA_InitializerSeq_var (const CORBA_InitializerSeq_var &); // copy constructor
-    ~CORBA_InitializerSeq_var (void); // destructor
-
-    CORBA_InitializerSeq_var &operator= (CORBA_InitializerSeq *);
-    CORBA_InitializerSeq_var &operator= (const CORBA_InitializerSeq_var &);
-    CORBA_InitializerSeq *operator-> (void);
-    const CORBA_InitializerSeq *operator-> (void) const;
-
-    operator const CORBA_InitializerSeq &() const;
-    operator CORBA_InitializerSeq &();
-    operator CORBA_InitializerSeq &() const;
-    CORBA_Initializer &operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_InitializerSeq &in (void) const;
-    CORBA_InitializerSeq &inout (void);
-    CORBA_InitializerSeq *&out (void);
-    CORBA_InitializerSeq *_retn (void);
-    CORBA_InitializerSeq *ptr (void) const;
+class TAO_Export ConsumesDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<ConsumesDef,ConsumesDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ConsumesDefSeq (void); // default ctor
+  ConsumesDefSeq (CORBA::ULong max); // uses max size
+  ConsumesDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ConsumesDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  ConsumesDefSeq (const ConsumesDefSeq &); // copy ctor
+  ~ConsumesDefSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_InitializerSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ConsumesDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_INITIALIZERSEQ___OUT_CH_)
-#define _CORBA_INITIALIZERSEQ___OUT_CH_
+#if !defined (_IR_CONSUMESDEFSEQ___VAR_CH_)
+#define _IR_CONSUMESDEFSEQ___VAR_CH_
 
-  class TAO_Export CORBA_InitializerSeq_out
-  {
-  public:
-    CORBA_InitializerSeq_out (CORBA_InitializerSeq *&);
-    CORBA_InitializerSeq_out (CORBA_InitializerSeq_var &);
-    CORBA_InitializerSeq_out (const CORBA_InitializerSeq_out &);
-    CORBA_InitializerSeq_out &operator= (const CORBA_InitializerSeq_out &);
-    CORBA_InitializerSeq_out &operator= (CORBA_InitializerSeq *);
-    operator CORBA_InitializerSeq *&();
-    CORBA_InitializerSeq *&ptr (void);
-    CORBA_InitializerSeq *operator-> (void);
-    CORBA_Initializer &operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::ConsumesDefSeq_var
+// *************************************************************
 
-  private:
-    CORBA_InitializerSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_InitializerSeq_var &);
-  };
+class TAO_Export ConsumesDefSeq_var
+{
+public:
+  ConsumesDefSeq_var (void); // default constructor
+  ConsumesDefSeq_var (ConsumesDefSeq *);
+  ConsumesDefSeq_var (const ConsumesDefSeq_var &); // copy constructor
+  ~ConsumesDefSeq_var (void); // destructor
+  
+  ConsumesDefSeq_var &operator= (ConsumesDefSeq *);
+  ConsumesDefSeq_var &operator= (const ConsumesDefSeq_var &);
+  ConsumesDefSeq *operator-> (void);
+  const ConsumesDefSeq *operator-> (void) const;
+  
+  operator const ConsumesDefSeq &() const;
+  operator ConsumesDefSeq &();
+  operator ConsumesDefSeq &() const;
+  operator ConsumesDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<ConsumesDef, ConsumesDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ConsumesDefSeq &in (void) const;
+  ConsumesDefSeq &inout (void);
+  ConsumesDefSeq *&out (void);
+  ConsumesDefSeq *_retn (void);
+  ConsumesDefSeq *ptr (void) const;
+
+private:
+  ConsumesDefSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-  struct  CORBA_UnionMember
-  {
-    static void _tao_any_destructor (void*);
 
-    TAO_String_Manager name;
-    CORBA::Any label;
-    CORBA::TypeCode_var type;
-    TAO_Object_Field_T<CORBA_IDLType,CORBA_IDLType_var> type_def;
-  };
+#if !defined (_IR_CONSUMESDEFSEQ___OUT_CH_)
+#define _IR_CONSUMESDEFSEQ___OUT_CH_
+
+class TAO_Export ConsumesDefSeq_out
+{
+public:
+  ConsumesDefSeq_out (ConsumesDefSeq *&);
+  ConsumesDefSeq_out (ConsumesDefSeq_var &);
+  ConsumesDefSeq_out (const ConsumesDefSeq_out &);
+  ConsumesDefSeq_out &operator= (const ConsumesDefSeq_out &);
+  ConsumesDefSeq_out &operator= (ConsumesDefSeq *);
+  operator ConsumesDefSeq *&();
+  ConsumesDefSeq *&ptr (void);
+  ConsumesDefSeq *operator-> (void);
+  TAO_Object_Manager<ConsumesDef, ConsumesDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  ConsumesDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ConsumesDefSeq_var &);
+};
 
-  class TAO_Export CORBA_UnionMember_var
-  {
-  public:
-    CORBA_UnionMember_var (void); // default constructor
-    CORBA_UnionMember_var (CORBA_UnionMember *);
-    CORBA_UnionMember_var (const CORBA_UnionMember_var &); // copy constructor
-    ~CORBA_UnionMember_var (void); // destructor
-
-    CORBA_UnionMember_var &operator= (CORBA_UnionMember *);
-    CORBA_UnionMember_var &operator= (const CORBA_UnionMember_var &);
-    CORBA_UnionMember *operator-> (void);
-    const CORBA_UnionMember *operator-> (void) const;
-
-    operator const CORBA_UnionMember &() const;
-    operator CORBA_UnionMember &();
-    operator CORBA_UnionMember &() const;
-    // in, inout, out, _retn
-    const CORBA_UnionMember &in (void) const;
-    CORBA_UnionMember &inout (void);
-    CORBA_UnionMember *&out (void);
-    CORBA_UnionMember *_retn (void);
-    CORBA_UnionMember *ptr (void) const;
 
-  private:
-    CORBA_UnionMember *ptr_;
-  };
+#endif /* end #if !defined */
 
-  class TAO_Export CORBA_UnionMember_out
-  {
-  public:
-    CORBA_UnionMember_out (CORBA_UnionMember *&);
-    CORBA_UnionMember_out (CORBA_UnionMember_var &);
-    CORBA_UnionMember_out (const CORBA_UnionMember_out &);
-    CORBA_UnionMember_out &operator= (const CORBA_UnionMember_out &);
-    CORBA_UnionMember_out &operator= (CORBA_UnionMember *);
-    operator CORBA_UnionMember *&();
-    CORBA_UnionMember *&ptr (void);
-    CORBA_UnionMember *operator-> (void);
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConsumesDefSeq;
 
-  private:
-    CORBA_UnionMember *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_UnionMember_var &);
-  };
+class FactoryDef;
 
+#if !defined (_IR_FACTORYDEF___PTR_CH_)
+#define _IR_FACTORYDEF___PTR_CH_
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+typedef FactoryDef *FactoryDef_ptr;
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CH_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CH_
+#endif /* end #if !defined */
 
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
 
-      _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void); // Default constructor.
-      _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_UnionMember *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs);
-      _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs);
-      virtual ~_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void); // Dtor.
-      // = Accessors.
-      CORBA_UnionMember &operator[] (CORBA::ULong i);
-      const CORBA_UnionMember &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static CORBA_UnionMember *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA_UnionMember *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+#if !defined (_IR_FACTORYDEF___VAR_CH_)
+#define _IR_FACTORYDEF___VAR_CH_
+
+class TAO_Export FactoryDef_var
+{
+public:
+  FactoryDef_var (void); // default constructor
+  FactoryDef_var (FactoryDef_ptr);
+  FactoryDef_var (const FactoryDef_var &); // copy constructor
+  ~FactoryDef_var (void); // destructor
+  
+  FactoryDef_var &operator= (FactoryDef_ptr);
+  FactoryDef_var &operator= (const FactoryDef_var &);
+  FactoryDef_ptr operator-> (void) const;
+  
+  operator const FactoryDef_ptr &() const;
+  operator FactoryDef_ptr &();
+  // in, inout, out, _retn 
+  FactoryDef_ptr in (void) const;
+  FactoryDef_ptr &inout (void);
+  FactoryDef_ptr &out (void);
+  FactoryDef_ptr _retn (void);
+  FactoryDef_ptr ptr (void) const;
+
+private:
+  FactoryDef_ptr ptr_;
+};
 
-      CORBA_UnionMember *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_UnionMember *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        CORBA_UnionMember *data,
-        CORBA::Boolean release);
-    };
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_FACTORYDEF___OUT_CH_)
+#define _IR_FACTORYDEF___OUT_CH_
 
-#if !defined (_CORBA_UNIONMEMBERSEQ_CH_)
-#define _CORBA_UNIONMEMBERSEQ_CH_
+class TAO_Export FactoryDef_out
+{
+public:
+  FactoryDef_out (FactoryDef_ptr &);
+  FactoryDef_out (FactoryDef_var &);
+  FactoryDef_out (const FactoryDef_out &);
+  FactoryDef_out &operator= (const FactoryDef_out &);
+  FactoryDef_out &operator= (const FactoryDef_var &);
+  FactoryDef_out &operator= (FactoryDef_ptr);
+  operator FactoryDef_ptr &();
+  FactoryDef_ptr &ptr (void);
+  FactoryDef_ptr operator-> (void);
+  
+private:
+  FactoryDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
 
-  // *************************************************************
-  // UnionMemberSeq
-  // *************************************************************
 
-  class TAO_Export CORBA_UnionMemberSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA_UnionMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_UnionMemberSeq (void); // default ctor
-    CORBA_UnionMemberSeq (CORBA::ULong max); // uses max size
-    CORBA_UnionMemberSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      CORBA_UnionMember *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_UnionMemberSeq (const CORBA_UnionMemberSeq &); // copy ctor
-    ~CORBA_UnionMemberSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      FactoryDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs);
+    TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var> operator[] (CORBA::ULong index) const;
+    static FactoryDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (FactoryDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    FactoryDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const FactoryDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_UNIONMEMBERSEQ___VAR_CH_)
-#define _CORBA_UNIONMEMBERSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_FACTORYDEFSEQ_CH_)
+#define _IR_FACTORYDEFSEQ_CH_
+
+class FactoryDefSeq;
+class FactoryDefSeq_var;
 
 // *************************************************************
-  // class CORBA::UnionMemberSeq_var
-  // *************************************************************
+// FactoryDefSeq
+// *************************************************************
 
-  class TAO_Export CORBA_UnionMemberSeq_var
-  {
-  public:
-    CORBA_UnionMemberSeq_var (void); // default constructor
-    CORBA_UnionMemberSeq_var (CORBA_UnionMemberSeq *);
-    CORBA_UnionMemberSeq_var (const CORBA_UnionMemberSeq_var &); // copy constructor
-    ~CORBA_UnionMemberSeq_var (void); // destructor
-
-    CORBA_UnionMemberSeq_var &operator= (CORBA_UnionMemberSeq *);
-    CORBA_UnionMemberSeq_var &operator= (const CORBA_UnionMemberSeq_var &);
-    CORBA_UnionMemberSeq *operator-> (void);
-    const CORBA_UnionMemberSeq *operator-> (void) const;
-
-    operator const CORBA_UnionMemberSeq &() const;
-    operator CORBA_UnionMemberSeq &();
-    operator CORBA_UnionMemberSeq &() const;
-    CORBA_UnionMember &operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_UnionMemberSeq &in (void) const;
-    CORBA_UnionMemberSeq &inout (void);
-    CORBA_UnionMemberSeq *&out (void);
-    CORBA_UnionMemberSeq *_retn (void);
-    CORBA_UnionMemberSeq *ptr (void) const;
+class TAO_Export FactoryDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<FactoryDef,FactoryDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  FactoryDefSeq (void); // default ctor
+  FactoryDefSeq (CORBA::ULong max); // uses max size
+  FactoryDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    FactoryDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  FactoryDefSeq (const FactoryDefSeq &); // copy ctor
+  ~FactoryDefSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_UnionMemberSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef FactoryDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_UNIONMEMBERSEQ___OUT_CH_)
-#define _CORBA_UNIONMEMBERSEQ___OUT_CH_
+#if !defined (_IR_FACTORYDEFSEQ___VAR_CH_)
+#define _IR_FACTORYDEFSEQ___VAR_CH_
 
-  class TAO_Export CORBA_UnionMemberSeq_out
-  {
-  public:
-    CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq *&);
-    CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq_var &);
-    CORBA_UnionMemberSeq_out (const CORBA_UnionMemberSeq_out &);
-    CORBA_UnionMemberSeq_out &operator= (const CORBA_UnionMemberSeq_out &);
-    CORBA_UnionMemberSeq_out &operator= (CORBA_UnionMemberSeq *);
-    operator CORBA_UnionMemberSeq *&();
-    CORBA_UnionMemberSeq *&ptr (void);
-    CORBA_UnionMemberSeq *operator-> (void);
-    CORBA_UnionMember &operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::FactoryDefSeq_var
+// *************************************************************
 
-  private:
-    CORBA_UnionMemberSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_UnionMemberSeq_var &);
-  };
+class TAO_Export FactoryDefSeq_var
+{
+public:
+  FactoryDefSeq_var (void); // default constructor
+  FactoryDefSeq_var (FactoryDefSeq *);
+  FactoryDefSeq_var (const FactoryDefSeq_var &); // copy constructor
+  ~FactoryDefSeq_var (void); // destructor
+  
+  FactoryDefSeq_var &operator= (FactoryDefSeq *);
+  FactoryDefSeq_var &operator= (const FactoryDefSeq_var &);
+  FactoryDefSeq *operator-> (void);
+  const FactoryDefSeq *operator-> (void) const;
+  
+  operator const FactoryDefSeq &() const;
+  operator FactoryDefSeq &();
+  operator FactoryDefSeq &() const;
+  operator FactoryDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<FactoryDef, FactoryDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const FactoryDefSeq &in (void) const;
+  FactoryDefSeq &inout (void);
+  FactoryDefSeq *&out (void);
+  FactoryDefSeq *_retn (void);
+  FactoryDefSeq *ptr (void) const;
+
+private:
+  FactoryDefSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ENUMMEMBERSEQ_CH_)
-#define _CORBA_ENUMMEMBERSEQ_CH_
+#if !defined (_IR_FACTORYDEFSEQ___OUT_CH_)
+#define _IR_FACTORYDEFSEQ___OUT_CH_
+
+class TAO_Export FactoryDefSeq_out
+{
+public:
+  FactoryDefSeq_out (FactoryDefSeq *&);
+  FactoryDefSeq_out (FactoryDefSeq_var &);
+  FactoryDefSeq_out (const FactoryDefSeq_out &);
+  FactoryDefSeq_out &operator= (const FactoryDefSeq_out &);
+  FactoryDefSeq_out &operator= (FactoryDefSeq *);
+  operator FactoryDefSeq *&();
+  FactoryDefSeq *&ptr (void);
+  FactoryDefSeq *operator-> (void);
+  TAO_Object_Manager<FactoryDef, FactoryDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  FactoryDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const FactoryDefSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FactoryDefSeq;
+
+class FinderDef;
+
+#if !defined (_IR_FINDERDEF___PTR_CH_)
+#define _IR_FINDERDEF___PTR_CH_
+
+typedef FinderDef *FinderDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEF___VAR_CH_)
+#define _IR_FINDERDEF___VAR_CH_
+
+class TAO_Export FinderDef_var
+{
+public:
+  FinderDef_var (void); // default constructor
+  FinderDef_var (FinderDef_ptr);
+  FinderDef_var (const FinderDef_var &); // copy constructor
+  ~FinderDef_var (void); // destructor
+  
+  FinderDef_var &operator= (FinderDef_ptr);
+  FinderDef_var &operator= (const FinderDef_var &);
+  FinderDef_ptr operator-> (void) const;
+  
+  operator const FinderDef_ptr &() const;
+  operator FinderDef_ptr &();
+  // in, inout, out, _retn 
+  FinderDef_ptr in (void) const;
+  FinderDef_ptr &inout (void);
+  FinderDef_ptr &out (void);
+  FinderDef_ptr _retn (void);
+  FinderDef_ptr ptr (void) const;
+
+private:
+  FinderDef_ptr ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEF___OUT_CH_)
+#define _IR_FINDERDEF___OUT_CH_
+
+class TAO_Export FinderDef_out
+{
+public:
+  FinderDef_out (FinderDef_ptr &);
+  FinderDef_out (FinderDef_var &);
+  FinderDef_out (const FinderDef_out &);
+  FinderDef_out &operator= (const FinderDef_out &);
+  FinderDef_out &operator= (const FinderDef_var &);
+  FinderDef_out &operator= (FinderDef_ptr);
+  operator FinderDef_ptr &();
+  FinderDef_ptr &ptr (void);
+  FinderDef_ptr operator-> (void);
+  
+private:
+  FinderDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
 
-  // *************************************************************
-  // EnumMemberSeq
-  // *************************************************************
 
-  class TAO_Export CORBA_EnumMemberSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_EnumMemberSeq (void); // default ctor
-    CORBA_EnumMemberSeq (CORBA::ULong max); // uses max size
-    CORBA_EnumMemberSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      char * *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_EnumMemberSeq (const CORBA_EnumMemberSeq &); // copy ctor
-    ~CORBA_EnumMemberSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      FinderDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs);
+    TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var> operator[] (CORBA::ULong index) const;
+    static FinderDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (FinderDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    FinderDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const FinderDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
+          TAO_default_environment ()
+      );
+    virtual CORBA_Object* _upcast (void *src) const;
+    
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ENUMMEMBERSEQ___VAR_CH_)
-#define _CORBA_ENUMMEMBERSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_FINDERDEFSEQ_CH_)
+#define _IR_FINDERDEFSEQ_CH_
+
+class FinderDefSeq;
+class FinderDefSeq_var;
 
 // *************************************************************
-  // class CORBA::EnumMemberSeq_var
-  // *************************************************************
+// FinderDefSeq
+// *************************************************************
 
-  class TAO_Export CORBA_EnumMemberSeq_var
-  {
-  public:
-    CORBA_EnumMemberSeq_var (void); // default constructor
-    CORBA_EnumMemberSeq_var (CORBA_EnumMemberSeq *);
-    CORBA_EnumMemberSeq_var (const CORBA_EnumMemberSeq_var &); // copy constructor
-    ~CORBA_EnumMemberSeq_var (void); // destructor
-
-    CORBA_EnumMemberSeq_var &operator= (CORBA_EnumMemberSeq *);
-    CORBA_EnumMemberSeq_var &operator= (const CORBA_EnumMemberSeq_var &);
-    CORBA_EnumMemberSeq *operator-> (void);
-    const CORBA_EnumMemberSeq *operator-> (void) const;
-
-    operator const CORBA_EnumMemberSeq &() const;
-    operator CORBA_EnumMemberSeq &();
-    operator CORBA_EnumMemberSeq &() const;
-    TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_EnumMemberSeq &in (void) const;
-    CORBA_EnumMemberSeq &inout (void);
-    CORBA_EnumMemberSeq *&out (void);
-    CORBA_EnumMemberSeq *_retn (void);
-    CORBA_EnumMemberSeq *ptr (void) const;
+class TAO_Export FinderDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<FinderDef,FinderDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  FinderDefSeq (void); // default ctor
+  FinderDefSeq (CORBA::ULong max); // uses max size
+  FinderDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    FinderDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  FinderDefSeq (const FinderDefSeq &); // copy ctor
+  ~FinderDefSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_EnumMemberSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef FinderDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ENUMMEMBERSEQ___OUT_CH_)
-#define _CORBA_ENUMMEMBERSEQ___OUT_CH_
+#if !defined (_IR_FINDERDEFSEQ___VAR_CH_)
+#define _IR_FINDERDEFSEQ___VAR_CH_
 
-  class TAO_Export CORBA_EnumMemberSeq_out
-  {
-  public:
-    CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq *&);
-    CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq_var &);
-    CORBA_EnumMemberSeq_out (const CORBA_EnumMemberSeq_out &);
-    CORBA_EnumMemberSeq_out &operator= (const CORBA_EnumMemberSeq_out &);
-    CORBA_EnumMemberSeq_out &operator= (CORBA_EnumMemberSeq *);
-    operator CORBA_EnumMemberSeq *&();
-    CORBA_EnumMemberSeq *&ptr (void);
-    CORBA_EnumMemberSeq *operator-> (void);
-    TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::FinderDefSeq_var
+// *************************************************************
 
-  private:
-    CORBA_EnumMemberSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_EnumMemberSeq_var &);
-  };
+class TAO_Export FinderDefSeq_var
+{
+public:
+  FinderDefSeq_var (void); // default constructor
+  FinderDefSeq_var (FinderDefSeq *);
+  FinderDefSeq_var (const FinderDefSeq_var &); // copy constructor
+  ~FinderDefSeq_var (void); // destructor
+  
+  FinderDefSeq_var &operator= (FinderDefSeq *);
+  FinderDefSeq_var &operator= (const FinderDefSeq_var &);
+  FinderDefSeq *operator-> (void);
+  const FinderDefSeq *operator-> (void) const;
+  
+  operator const FinderDefSeq &() const;
+  operator FinderDefSeq &();
+  operator FinderDefSeq &() const;
+  operator FinderDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<FinderDef, FinderDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const FinderDefSeq &in (void) const;
+  FinderDefSeq &inout (void);
+  FinderDefSeq *&out (void);
+  FinderDefSeq *_retn (void);
+  FinderDefSeq *ptr (void) const;
+
+private:
+  FinderDefSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_CONTAINER___VAR_CH_)
-#define _CORBA_CONTAINER___VAR_CH_
 
-  class TAO_Export CORBA_Container_var
-  {
-  public:
-    CORBA_Container_var (void); // default constructor
-    CORBA_Container_var (CORBA_Container_ptr);
-    CORBA_Container_var (const CORBA_Container_var &); // copy constructor
-    ~CORBA_Container_var (void); // destructor
+#if !defined (_IR_FINDERDEFSEQ___OUT_CH_)
+#define _IR_FINDERDEFSEQ___OUT_CH_
+
+class TAO_Export FinderDefSeq_out
+{
+public:
+  FinderDefSeq_out (FinderDefSeq *&);
+  FinderDefSeq_out (FinderDefSeq_var &);
+  FinderDefSeq_out (const FinderDefSeq_out &);
+  FinderDefSeq_out &operator= (const FinderDefSeq_out &);
+  FinderDefSeq_out &operator= (FinderDefSeq *);
+  operator FinderDefSeq *&();
+  FinderDefSeq *&ptr (void);
+  FinderDefSeq *operator-> (void);
+  TAO_Object_Manager<FinderDef, FinderDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  FinderDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const FinderDefSeq_var &);
+};
 
-    CORBA_Container_var &operator= (CORBA_Container_ptr);
-    CORBA_Container_var &operator= (const CORBA_Container_var &);
-    CORBA_Container_ptr operator-> (void) const;
 
-    operator const CORBA_Container_ptr &() const;
-    operator CORBA_Container_ptr &();
-    // in, inout, out, _retn
-    CORBA_Container_ptr in (void) const;
-    CORBA_Container_ptr &inout (void);
-    CORBA_Container_ptr &out (void);
-    CORBA_Container_ptr _retn (void);
-    CORBA_Container_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_Container_ptr ptr_;
-  };
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FinderDefSeq;
 
+class PrimaryKeyDef;
+
+#if !defined (_IR_PRIMARYKEYDEF___PTR_CH_)
+#define _IR_PRIMARYKEYDEF___PTR_CH_
+
+typedef PrimaryKeyDef *PrimaryKeyDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINER___OUT_CH_)
-#define _CORBA_CONTAINER___OUT_CH_
+#if !defined (_IR_PRIMARYKEYDEF___VAR_CH_)
+#define _IR_PRIMARYKEYDEF___VAR_CH_
+
+class TAO_Export PrimaryKeyDef_var
+{
+public:
+  PrimaryKeyDef_var (void); // default constructor
+  PrimaryKeyDef_var (PrimaryKeyDef_ptr);
+  PrimaryKeyDef_var (const PrimaryKeyDef_var &); // copy constructor
+  ~PrimaryKeyDef_var (void); // destructor
+  
+  PrimaryKeyDef_var &operator= (PrimaryKeyDef_ptr);
+  PrimaryKeyDef_var &operator= (const PrimaryKeyDef_var &);
+  PrimaryKeyDef_ptr operator-> (void) const;
+  
+  operator const PrimaryKeyDef_ptr &() const;
+  operator PrimaryKeyDef_ptr &();
+  // in, inout, out, _retn 
+  PrimaryKeyDef_ptr in (void) const;
+  PrimaryKeyDef_ptr &inout (void);
+  PrimaryKeyDef_ptr &out (void);
+  PrimaryKeyDef_ptr _retn (void);
+  PrimaryKeyDef_ptr ptr (void) const;
+
+private:
+  PrimaryKeyDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_Container_out
-  {
-  public:
-    CORBA_Container_out (CORBA_Container_ptr &);
-    CORBA_Container_out (CORBA_Container_var &);
-    CORBA_Container_out (const CORBA_Container_out &);
-    CORBA_Container_out &operator= (const CORBA_Container_out &);
-    CORBA_Container_out &operator= (const CORBA_Container_var &);
-    CORBA_Container_out &operator= (CORBA_Container_ptr);
-    operator CORBA_Container_ptr &();
-    CORBA_Container_ptr &ptr (void);
-    CORBA_Container_ptr operator-> (void);
 
-  private:
-    CORBA_Container_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___OUT_CH_)
+#define _IR_PRIMARYKEYDEF___OUT_CH_
+
+class TAO_Export PrimaryKeyDef_out
+{
+public:
+  PrimaryKeyDef_out (PrimaryKeyDef_ptr &);
+  PrimaryKeyDef_out (PrimaryKeyDef_var &);
+  PrimaryKeyDef_out (const PrimaryKeyDef_out &);
+  PrimaryKeyDef_out &operator= (const PrimaryKeyDef_out &);
+  PrimaryKeyDef_out &operator= (const PrimaryKeyDef_var &);
+  PrimaryKeyDef_out &operator= (PrimaryKeyDef_ptr);
+  operator PrimaryKeyDef_ptr &();
+  PrimaryKeyDef_ptr &ptr (void);
+  PrimaryKeyDef_ptr operator-> (void);
+  
+private:
+  PrimaryKeyDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINER_CH_)
-#define _CORBA_CONTAINER_CH_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONTAINEDSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONTAINEDSEQ_CH_
 
-class TAO_Export CORBA_Container: public virtual CORBA_IRObject
+  class _TAO_Unbounded_Object_Sequence_IR_ContainedSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_Container_ptr _ptr_type;
-    typedef CORBA_Container_var _var_type;
-  #endif /* __GNUC__ */
-
-    // the static operations
-    static CORBA_Container_ptr _duplicate (CORBA_Container_ptr obj);
-    static CORBA_Container_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_Container_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      Contained* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq(const _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &rhs);
+    TAO_Object_Manager<IR::Contained,IR::Contained_var> operator[] (CORBA::ULong index) const;
+    static Contained **allocbuf (CORBA::ULong nelems);
+    static void freebuf (Contained **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    Contained* *get_buffer (CORBA::Boolean orphan = 0);
+    const Contained* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       );
-    static CORBA_Container_ptr _nil (void)
-      {
-        return (CORBA::Container_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+    virtual CORBA_Object* _upcast (void *src) const;
+    
+  };
 
-    virtual CORBA_Contained_ptr lookup (
-        const char * search_name,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_ContainedSeq * contents (
-        CORBA::DefinitionKind limit_type,
-        CORBA::Boolean exclude_inherited,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_ContainedSeq * lookup_name (
-        const char * search_name,
-        CORBA::Long levels_to_search,
-        CORBA::DefinitionKind limit_type,
-        CORBA::Boolean exclude_inherited,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-    struct  Description
-    {
-      static void _tao_any_destructor (void*);
+#if !defined (_IR_CONTAINEDSEQ_CH_)
+#define _IR_CONTAINEDSEQ_CH_
 
-      TAO_Object_Field_T<CORBA_Contained,CORBA_Contained_var> contained_object;
-      CORBA::DefinitionKind kind;
-      CORBA::Any value;
-    };
+class ContainedSeq;
+class ContainedSeq_var;
 
-    class  Description_var
-    {
-    public:
-      Description_var (void); // default constructor
-      Description_var (Description *);
-      Description_var (const Description_var &); // copy constructor
-      ~Description_var (void); // destructor
+// *************************************************************
+// ContainedSeq
+// *************************************************************
 
-      Description_var &operator= (Description *);
-      Description_var &operator= (const Description_var &);
-      Description *operator-> (void);
-      const Description *operator-> (void) const;
+class TAO_Export ContainedSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ContainedSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<Contained,Contained_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ContainedSeq (void); // default ctor
+  ContainedSeq (CORBA::ULong max); // uses max size
+  ContainedSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    Contained_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  ContainedSeq (const ContainedSeq &); // copy ctor
+  ~ContainedSeq (void);
+  static void _tao_any_destructor (void*);
 
-      operator const Description &() const;
-      operator Description &();
-      operator Description &() const;
-      // in, inout, out, _retn
-      const Description &in (void) const;
-      Description &inout (void);
-      Description *&out (void);
-      Description *_retn (void);
-      Description *ptr (void) const;
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ContainedSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-    private:
-      Description *ptr_;
-    };
+};
 
-    class  Description_out
-    {
-    public:
-      Description_out (Description *&);
-      Description_out (Description_var &);
-      Description_out (const Description_out &);
-      Description_out &operator= (const Description_out &);
-      Description_out &operator= (Description *);
-      operator Description *&();
-      Description *&ptr (void);
-      Description *operator-> (void);
+#endif /* end #if !defined */
 
-    private:
-      Description *&ptr_;
-      // assignment from T_var not allowed
-      void operator= (const Description_var &);
-    };
 
-    static CORBA::TypeCode_ptr _tc_Description;
+#if !defined (_IR_CONTAINEDSEQ___VAR_CH_)
+#define _IR_CONTAINEDSEQ___VAR_CH_
 
+// *************************************************************
+// class IR::ContainedSeq_var
+// *************************************************************
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+class TAO_Export ContainedSeq_var
+{
+public:
+  ContainedSeq_var (void); // default constructor
+  ContainedSeq_var (ContainedSeq *);
+  ContainedSeq_var (const ContainedSeq_var &); // copy constructor
+  ~ContainedSeq_var (void); // destructor
+  
+  ContainedSeq_var &operator= (ContainedSeq *);
+  ContainedSeq_var &operator= (const ContainedSeq_var &);
+  ContainedSeq *operator-> (void);
+  const ContainedSeq *operator-> (void) const;
+  
+  operator const ContainedSeq &() const;
+  operator ContainedSeq &();
+  operator ContainedSeq &() const;
+  operator ContainedSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<Contained, Contained_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ContainedSeq &in (void) const;
+  ContainedSeq &inout (void);
+  ContainedSeq *&out (void);
+  ContainedSeq *_retn (void);
+  ContainedSeq *ptr (void) const;
+
+private:
+  ContainedSeq *ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONTAINEDSEQ___OUT_CH_)
+#define _IR_CONTAINEDSEQ___OUT_CH_
+
+class TAO_Export ContainedSeq_out
+{
+public:
+  ContainedSeq_out (ContainedSeq *&);
+  ContainedSeq_out (ContainedSeq_var &);
+  ContainedSeq_out (const ContainedSeq_out &);
+  ContainedSeq_out &operator= (const ContainedSeq_out &);
+  ContainedSeq_out &operator= (ContainedSeq *);
+  operator ContainedSeq *&();
+  ContainedSeq *&ptr (void);
+  ContainedSeq *operator-> (void);
+  TAO_Object_Manager<Contained, Contained_var> operator[] (CORBA::ULong index);
+  
+private:
+  ContainedSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ContainedSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContainedSeq;
+
+struct StructMember;
+class StructMember_var;
+
+struct TAO_Export StructMember
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef StructMember_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  CORBA::TypeCode_var type;
+  TAO_Object_Field_T<ACE_NESTED_CLASS (IR, IDLType), ACE_NESTED_CLASS (IR, IDLType_var)> type_def;
+};
+
+class TAO_Export StructMember_var
+{
+public:
+  StructMember_var (void); // default constructor
+  StructMember_var (StructMember *);
+  StructMember_var (const StructMember_var &); // copy constructor
+  ~StructMember_var (void); // destructor
+  
+  StructMember_var &operator= (StructMember *);
+  StructMember_var &operator= (const StructMember_var &);
+  StructMember *operator-> (void);
+  const StructMember *operator-> (void) const;
+  
+  operator const StructMember &() const;
+  operator StructMember &();
+  operator StructMember &() const;
+  operator StructMember *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const StructMember &in (void) const;
+  StructMember &inout (void);
+  StructMember *&out (void);
+  StructMember *_retn (void);
+  StructMember *ptr (void) const;
+
+private:
+  StructMember *ptr_;
+};
+
+class TAO_Export StructMember_out
+{
+public:
+  StructMember_out (StructMember *&);
+  StructMember_out (StructMember_var &);
+  StructMember_out (const StructMember_out &);
+  StructMember_out &operator= (const StructMember_out &);
+  StructMember_out &operator= (StructMember *);
+  operator StructMember *&();
+  StructMember *&ptr (void);
+  StructMember *operator-> (void);
+  
+private:
+  StructMember *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const StructMember_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMember;
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CH_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CH_
 
-      class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq : public TAO_Unbounded_Base_Sequence
-      {
-      public:
-        // = Initialization and termination methods.
-
-        _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (void); // Default constructor.
-        _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum);
-        _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum,
-          CORBA::ULong length,
-          Description *data,
-          CORBA::Boolean release = 0);
-        _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs);
-        _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs);
-        virtual ~_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (void); // Dtor.
-        // = Accessors.
-        Description &operator[] (CORBA::ULong i);
-        const Description &operator[] (CORBA::ULong i) const;
-        // = Static operations.
-        static Description *allocbuf (CORBA::ULong size);
-        static void freebuf (Description *buffer);
-        virtual void _allocate_buffer (CORBA::ULong length);
-        virtual void _deallocate_buffer (void);
-        // Implement the TAO_Base_Sequence methods (see Sequence.h)
-
-        Description *get_buffer (CORBA::Boolean orphan = 0);
-        const Description *get_buffer (void) const;
-        void replace (CORBA::ULong max,
-          CORBA::ULong length,
-          Description *data,
-          CORBA::Boolean release);
-      };
-
-#endif /* end #if !defined */
-
-
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-
-#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ_CH_)
-#define _CORBA_CONTAINER_DESCRIPTIONSEQ_CH_
-
-    // *************************************************************
-    // DescriptionSeq
-    // *************************************************************
-
-    class  DescriptionSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-      _TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-      TAO_Unbounded_Sequence<Description>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-    {
-    public:
-      DescriptionSeq (void); // default ctor
-      DescriptionSeq (CORBA::ULong max); // uses max size
-      DescriptionSeq (
-        CORBA::ULong max,
-        CORBA::ULong length,
-        Description *buffer,
-        CORBA::Boolean release=0
-      );
-      DescriptionSeq (const DescriptionSeq &); // copy ctor
-      ~DescriptionSeq (void); // dtor
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_STRUCTMEMBERSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_STRUCTMEMBERSEQ_CH_
 
-      static void _tao_any_destructor (void*);
-    };
-    typedef DescriptionSeq *DescriptionSeq_ptr;
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_StructMemberSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_StructMemberSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      StructMember *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_StructMemberSeq (const _TAO_Unbounded_Sequence_IR_StructMemberSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_StructMemberSeq &operator= (const _TAO_Unbounded_Sequence_IR_StructMemberSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_StructMemberSeq (void); // Dtor.
+    // = Accessors.
+    StructMember &operator[] (CORBA::ULong i);
+    const StructMember &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static StructMember *allocbuf (CORBA::ULong size);
+    static void freebuf (StructMember *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    StructMember *get_buffer (CORBA::Boolean orphan = 0);
+    const StructMember *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      StructMember *data,
+      CORBA::Boolean release);
+  };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ___VAR_CH_)
-#define _CORBA_CONTAINER_DESCRIPTIONSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_STRUCTMEMBERSEQ_CH_)
+#define _IR_STRUCTMEMBERSEQ_CH_
+
+class StructMemberSeq;
+class StructMemberSeq_var;
 
 // *************************************************************
-    // class CORBA::Container::DescriptionSeq_var
-    // *************************************************************
+// StructMemberSeq
+// *************************************************************
 
-    class  DescriptionSeq_var
-    {
-    public:
-      DescriptionSeq_var (void); // default constructor
-      DescriptionSeq_var (DescriptionSeq *);
-      DescriptionSeq_var (const DescriptionSeq_var &); // copy constructor
-      ~DescriptionSeq_var (void); // destructor
-
-      DescriptionSeq_var &operator= (DescriptionSeq *);
-      DescriptionSeq_var &operator= (const DescriptionSeq_var &);
-      DescriptionSeq *operator-> (void);
-      const DescriptionSeq *operator-> (void) const;
-
-      operator const DescriptionSeq &() const;
-      operator DescriptionSeq &();
-      operator DescriptionSeq &() const;
-      Description &operator[] (CORBA::ULong index);
-      // in, inout, out, _retn
-      const DescriptionSeq &in (void) const;
-      DescriptionSeq &inout (void);
-      DescriptionSeq *&out (void);
-      DescriptionSeq *_retn (void);
-      DescriptionSeq *ptr (void) const;
+class TAO_Export StructMemberSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_StructMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<StructMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  StructMemberSeq (void); // default ctor
+  StructMemberSeq (CORBA::ULong max); // uses max size
+  StructMemberSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    StructMember *buffer, 
+    CORBA::Boolean release=0
+  );
+  StructMemberSeq (const StructMemberSeq &); // copy ctor
+  ~StructMemberSeq (void);
+  static void _tao_any_destructor (void*);
 
-    private:
-      DescriptionSeq *ptr_;
-    };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef StructMemberSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ___OUT_CH_)
-#define _CORBA_CONTAINER_DESCRIPTIONSEQ___OUT_CH_
+#if !defined (_IR_STRUCTMEMBERSEQ___VAR_CH_)
+#define _IR_STRUCTMEMBERSEQ___VAR_CH_
 
-    class  DescriptionSeq_out
-    {
-    public:
-      DescriptionSeq_out (DescriptionSeq *&);
-      DescriptionSeq_out (DescriptionSeq_var &);
-      DescriptionSeq_out (const DescriptionSeq_out &);
-      DescriptionSeq_out &operator= (const DescriptionSeq_out &);
-      DescriptionSeq_out &operator= (DescriptionSeq *);
-      operator DescriptionSeq *&();
-      DescriptionSeq *&ptr (void);
-      DescriptionSeq *operator-> (void);
-      Description &operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::StructMemberSeq_var
+// *************************************************************
 
-    private:
-      DescriptionSeq *&ptr_;
-      // assignment from T_var not allowed
-      void operator= (const DescriptionSeq_var &);
-    };
+class TAO_Export StructMemberSeq_var
+{
+public:
+  StructMemberSeq_var (void); // default constructor
+  StructMemberSeq_var (StructMemberSeq *);
+  StructMemberSeq_var (const StructMemberSeq_var &); // copy constructor
+  ~StructMemberSeq_var (void); // destructor
+  
+  StructMemberSeq_var &operator= (StructMemberSeq *);
+  StructMemberSeq_var &operator= (const StructMemberSeq_var &);
+  StructMemberSeq *operator-> (void);
+  const StructMemberSeq *operator-> (void) const;
+  
+  operator const StructMemberSeq &() const;
+  operator StructMemberSeq &();
+  operator StructMemberSeq &() const;
+  operator StructMemberSeq *&(); // variable-size base types only
+  
+  StructMember &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const StructMemberSeq &in (void) const;
+  StructMemberSeq &inout (void);
+  StructMemberSeq *&out (void);
+  StructMemberSeq *_retn (void);
+  StructMemberSeq *ptr (void) const;
+
+private:
+  StructMemberSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-    static CORBA::TypeCode_ptr _tc_DescriptionSeq;
 
-    virtual DescriptionSeq * describe_contents (
-        CORBA::DefinitionKind limit_type,
-        CORBA::Boolean exclude_inherited,
-        CORBA::Long max_returned_objs,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_STRUCTMEMBERSEQ___OUT_CH_)
+#define _IR_STRUCTMEMBERSEQ___OUT_CH_
+
+class TAO_Export StructMemberSeq_out
+{
+public:
+  StructMemberSeq_out (StructMemberSeq *&);
+  StructMemberSeq_out (StructMemberSeq_var &);
+  StructMemberSeq_out (const StructMemberSeq_out &);
+  StructMemberSeq_out &operator= (const StructMemberSeq_out &);
+  StructMemberSeq_out &operator= (StructMemberSeq *);
+  operator StructMemberSeq *&();
+  StructMemberSeq *&ptr (void);
+  StructMemberSeq *operator-> (void);
+  StructMember &operator[] (CORBA::ULong index);
+  
+private:
+  StructMemberSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const StructMemberSeq_var &);
+};
 
-    virtual CORBA_ModuleDef_ptr create_module (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_ConstantDef_ptr create_constant (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA_IDLType_ptr type,
-        const CORBA::Any & value,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_StructDef_ptr create_struct (
-        const char * id,
-        const char * name,
-        const char * version,
-        const CORBA_StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMemberSeq;
+
+struct Initializer;
+class Initializer_var;
+
+struct TAO_Export Initializer
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef Initializer_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  ACE_NESTED_CLASS (IR, StructMemberSeq) members;
+  TAO_String_Manager name;
+};
+
+class TAO_Export Initializer_var
+{
+public:
+  Initializer_var (void); // default constructor
+  Initializer_var (Initializer *);
+  Initializer_var (const Initializer_var &); // copy constructor
+  ~Initializer_var (void); // destructor
+  
+  Initializer_var &operator= (Initializer *);
+  Initializer_var &operator= (const Initializer_var &);
+  Initializer *operator-> (void);
+  const Initializer *operator-> (void) const;
+  
+  operator const Initializer &() const;
+  operator Initializer &();
+  operator Initializer &() const;
+  operator Initializer *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const Initializer &in (void) const;
+  Initializer &inout (void);
+  Initializer *&out (void);
+  Initializer *_retn (void);
+  Initializer *ptr (void) const;
+
+private:
+  Initializer *ptr_;
+};
+
+class TAO_Export Initializer_out
+{
+public:
+  Initializer_out (Initializer *&);
+  Initializer_out (Initializer_var &);
+  Initializer_out (const Initializer_out &);
+  Initializer_out &operator= (const Initializer_out &);
+  Initializer_out &operator= (Initializer *);
+  operator Initializer *&();
+  Initializer *&ptr (void);
+  Initializer *operator-> (void);
+  
+private:
+  Initializer *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const Initializer_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Initializer;
 
-    virtual CORBA_UnionDef_ptr create_union (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA_IDLType_ptr discriminator_type,
-        const CORBA_UnionMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_EnumDef_ptr create_enum (
-        const char * id,
-        const char * name,
-        const char * version,
-        const CORBA_EnumMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_INITIALIZERSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_INITIALIZERSEQ_CH_
 
-    virtual CORBA_AliasDef_ptr create_alias (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA_IDLType_ptr original_type,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_InitializerSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_InitializerSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      Initializer *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_InitializerSeq (const _TAO_Unbounded_Sequence_IR_InitializerSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_InitializerSeq &operator= (const _TAO_Unbounded_Sequence_IR_InitializerSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_InitializerSeq (void); // Dtor.
+    // = Accessors.
+    Initializer &operator[] (CORBA::ULong i);
+    const Initializer &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static Initializer *allocbuf (CORBA::ULong size);
+    static void freebuf (Initializer *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    Initializer *get_buffer (CORBA::Boolean orphan = 0);
+    const Initializer *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      Initializer *data,
+      CORBA::Boolean release);
+  };
 
-    virtual CORBA_InterfaceDef_ptr create_interface (
-        const char * id,
-        const char * name,
-        const char * version,
-        const CORBA_InterfaceDefSeq & base_interfaces,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_ValueDef_ptr create_value (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA::Boolean is_custom,
-        CORBA::Boolean is_abstract,
-        CORBA_ValueDef_ptr base_value,
-        CORBA::Boolean is_truncatable,
-        const CORBA_ValueDefSeq & abstract_base_values,
-        CORBA_InterfaceDef_ptr supported_interface,
-        const CORBA_InitializerSeq & initializers,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_ValueBoxDef_ptr create_value_box (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA_IDLType_ptr original_type_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-    virtual CORBA_ExceptionDef_ptr create_exception (
-        const char * id,
-        const char * name,
-        const char * version,
-        const CORBA_StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_INITIALIZERSEQ_CH_)
+#define _IR_INITIALIZERSEQ_CH_
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+class InitializerSeq;
+class InitializerSeq_var;
 
-  protected:
-    CORBA_Container (void);
-    CORBA_Container (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_Container (void);
-  private:
-    CORBA_Container (const CORBA_Container &);
-    void operator= (const CORBA_Container &);
-  };
+// *************************************************************
+// InitializerSeq
+// *************************************************************
 
+class TAO_Export InitializerSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_InitializerSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<Initializer>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  InitializerSeq (void); // default ctor
+  InitializerSeq (CORBA::ULong max); // uses max size
+  InitializerSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    Initializer *buffer, 
+    CORBA::Boolean release=0
+  );
+  InitializerSeq (const InitializerSeq &); // copy ctor
+  ~InitializerSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef InitializerSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_IDLTYPE___VAR_CH_)
-#define _CORBA_IDLTYPE___VAR_CH_
+#if !defined (_IR_INITIALIZERSEQ___VAR_CH_)
+#define _IR_INITIALIZERSEQ___VAR_CH_
 
-  class TAO_Export CORBA_IDLType_var
-  {
-  public:
-    CORBA_IDLType_var (void); // default constructor
-    CORBA_IDLType_var (CORBA_IDLType_ptr);
-    CORBA_IDLType_var (const CORBA_IDLType_var &); // copy constructor
-    ~CORBA_IDLType_var (void); // destructor
+// *************************************************************
+// class IR::InitializerSeq_var
+// *************************************************************
 
-    CORBA_IDLType_var &operator= (CORBA_IDLType_ptr);
-    CORBA_IDLType_var &operator= (const CORBA_IDLType_var &);
-    CORBA_IDLType_ptr operator-> (void) const;
+class TAO_Export InitializerSeq_var
+{
+public:
+  InitializerSeq_var (void); // default constructor
+  InitializerSeq_var (InitializerSeq *);
+  InitializerSeq_var (const InitializerSeq_var &); // copy constructor
+  ~InitializerSeq_var (void); // destructor
+  
+  InitializerSeq_var &operator= (InitializerSeq *);
+  InitializerSeq_var &operator= (const InitializerSeq_var &);
+  InitializerSeq *operator-> (void);
+  const InitializerSeq *operator-> (void) const;
+  
+  operator const InitializerSeq &() const;
+  operator InitializerSeq &();
+  operator InitializerSeq &() const;
+  operator InitializerSeq *&(); // variable-size base types only
+  
+  Initializer &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const InitializerSeq &in (void) const;
+  InitializerSeq &inout (void);
+  InitializerSeq *&out (void);
+  InitializerSeq *_retn (void);
+  InitializerSeq *ptr (void) const;
+
+private:
+  InitializerSeq *ptr_;
+};
 
-    operator const CORBA_IDLType_ptr &() const;
-    operator CORBA_IDLType_ptr &();
-    // in, inout, out, _retn
-    CORBA_IDLType_ptr in (void) const;
-    CORBA_IDLType_ptr &inout (void);
-    CORBA_IDLType_ptr &out (void);
-    CORBA_IDLType_ptr _retn (void);
-    CORBA_IDLType_ptr ptr (void) const;
 
-  private:
-    CORBA_IDLType_ptr ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_INITIALIZERSEQ___OUT_CH_)
+#define _IR_INITIALIZERSEQ___OUT_CH_
+
+class TAO_Export InitializerSeq_out
+{
+public:
+  InitializerSeq_out (InitializerSeq *&);
+  InitializerSeq_out (InitializerSeq_var &);
+  InitializerSeq_out (const InitializerSeq_out &);
+  InitializerSeq_out &operator= (const InitializerSeq_out &);
+  InitializerSeq_out &operator= (InitializerSeq *);
+  operator InitializerSeq *&();
+  InitializerSeq *&ptr (void);
+  InitializerSeq *operator-> (void);
+  Initializer &operator[] (CORBA::ULong index);
+  
+private:
+  InitializerSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const InitializerSeq_var &);
+};
 
 
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InitializerSeq;
+
+struct UnionMember;
+class UnionMember_var;
+
+struct TAO_Export UnionMember
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UnionMember_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  CORBA::Any label;
+  CORBA::TypeCode_var type;
+  TAO_Object_Field_T<ACE_NESTED_CLASS (IR, IDLType), ACE_NESTED_CLASS (IR, IDLType_var)> type_def;
+};
+
+class TAO_Export UnionMember_var
+{
+public:
+  UnionMember_var (void); // default constructor
+  UnionMember_var (UnionMember *);
+  UnionMember_var (const UnionMember_var &); // copy constructor
+  ~UnionMember_var (void); // destructor
+  
+  UnionMember_var &operator= (UnionMember *);
+  UnionMember_var &operator= (const UnionMember_var &);
+  UnionMember *operator-> (void);
+  const UnionMember *operator-> (void) const;
+  
+  operator const UnionMember &() const;
+  operator UnionMember &();
+  operator UnionMember &() const;
+  operator UnionMember *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const UnionMember &in (void) const;
+  UnionMember &inout (void);
+  UnionMember *&out (void);
+  UnionMember *_retn (void);
+  UnionMember *ptr (void) const;
+
+private:
+  UnionMember *ptr_;
+};
+
+class TAO_Export UnionMember_out
+{
+public:
+  UnionMember_out (UnionMember *&);
+  UnionMember_out (UnionMember_var &);
+  UnionMember_out (const UnionMember_out &);
+  UnionMember_out &operator= (const UnionMember_out &);
+  UnionMember_out &operator= (UnionMember *);
+  operator UnionMember *&();
+  UnionMember *&ptr (void);
+  UnionMember *operator-> (void);
+  
+private:
+  UnionMember *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const UnionMember_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMember;
+
 
-#if !defined (_CORBA_IDLTYPE___OUT_CH_)
-#define _CORBA_IDLTYPE___OUT_CH_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_UNIONMEMBERSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_UNIONMEMBERSEQ_CH_
 
-  class TAO_Export CORBA_IDLType_out
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_UnionMemberSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_IDLType_out (CORBA_IDLType_ptr &);
-    CORBA_IDLType_out (CORBA_IDLType_var &);
-    CORBA_IDLType_out (const CORBA_IDLType_out &);
-    CORBA_IDLType_out &operator= (const CORBA_IDLType_out &);
-    CORBA_IDLType_out &operator= (const CORBA_IDLType_var &);
-    CORBA_IDLType_out &operator= (CORBA_IDLType_ptr);
-    operator CORBA_IDLType_ptr &();
-    CORBA_IDLType_ptr &ptr (void);
-    CORBA_IDLType_ptr operator-> (void);
-
-  private:
-    CORBA_IDLType_ptr &ptr_;
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_UnionMemberSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      UnionMember *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_UnionMemberSeq (const _TAO_Unbounded_Sequence_IR_UnionMemberSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_UnionMemberSeq &operator= (const _TAO_Unbounded_Sequence_IR_UnionMemberSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_UnionMemberSeq (void); // Dtor.
+    // = Accessors.
+    UnionMember &operator[] (CORBA::ULong i);
+    const UnionMember &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static UnionMember *allocbuf (CORBA::ULong size);
+    static void freebuf (UnionMember *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    UnionMember *get_buffer (CORBA::Boolean orphan = 0);
+    const UnionMember *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      UnionMember *data,
+      CORBA::Boolean release);
   };
 
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_UNIONMEMBERSEQ_CH_)
+#define _IR_UNIONMEMBERSEQ_CH_
+
+class UnionMemberSeq;
+class UnionMemberSeq_var;
+
+// *************************************************************
+// UnionMemberSeq
+// *************************************************************
+
+class TAO_Export UnionMemberSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_UnionMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<UnionMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  UnionMemberSeq (void); // default ctor
+  UnionMemberSeq (CORBA::ULong max); // uses max size
+  UnionMemberSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    UnionMember *buffer, 
+    CORBA::Boolean release=0
+  );
+  UnionMemberSeq (const UnionMemberSeq &); // copy ctor
+  ~UnionMemberSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UnionMemberSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_IDLTYPE_CH_)
-#define _CORBA_IDLTYPE_CH_
+#if !defined (_IR_UNIONMEMBERSEQ___VAR_CH_)
+#define _IR_UNIONMEMBERSEQ___VAR_CH_
 
-class TAO_Export CORBA_IDLType: public virtual CORBA_IRObject
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_IDLType_ptr _ptr_type;
-    typedef CORBA_IDLType_var _var_type;
-  #endif /* __GNUC__ */
+// *************************************************************
+// class IR::UnionMemberSeq_var
+// *************************************************************
 
-    // the static operations
-    static CORBA_IDLType_ptr _duplicate (CORBA_IDLType_ptr obj);
-    static CORBA_IDLType_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_IDLType_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_IDLType_ptr _nil (void)
-      {
-        return (CORBA::IDLType_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+class TAO_Export UnionMemberSeq_var
+{
+public:
+  UnionMemberSeq_var (void); // default constructor
+  UnionMemberSeq_var (UnionMemberSeq *);
+  UnionMemberSeq_var (const UnionMemberSeq_var &); // copy constructor
+  ~UnionMemberSeq_var (void); // destructor
+  
+  UnionMemberSeq_var &operator= (UnionMemberSeq *);
+  UnionMemberSeq_var &operator= (const UnionMemberSeq_var &);
+  UnionMemberSeq *operator-> (void);
+  const UnionMemberSeq *operator-> (void) const;
+  
+  operator const UnionMemberSeq &() const;
+  operator UnionMemberSeq &();
+  operator UnionMemberSeq &() const;
+  operator UnionMemberSeq *&(); // variable-size base types only
+  
+  UnionMember &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const UnionMemberSeq &in (void) const;
+  UnionMemberSeq &inout (void);
+  UnionMemberSeq *&out (void);
+  UnionMemberSeq *_retn (void);
+  UnionMemberSeq *ptr (void) const;
+
+private:
+  UnionMemberSeq *ptr_;
+};
 
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+#endif /* end #if !defined */
 
-  protected:
-    CORBA_IDLType (void);
-    CORBA_IDLType (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_IDLType (void);
-  private:
-    CORBA_IDLType (const CORBA_IDLType &);
-    void operator= (const CORBA_IDLType &);
-  };
+
+#if !defined (_IR_UNIONMEMBERSEQ___OUT_CH_)
+#define _IR_UNIONMEMBERSEQ___OUT_CH_
+
+class TAO_Export UnionMemberSeq_out
+{
+public:
+  UnionMemberSeq_out (UnionMemberSeq *&);
+  UnionMemberSeq_out (UnionMemberSeq_var &);
+  UnionMemberSeq_out (const UnionMemberSeq_out &);
+  UnionMemberSeq_out &operator= (const UnionMemberSeq_out &);
+  UnionMemberSeq_out &operator= (UnionMemberSeq *);
+  operator UnionMemberSeq *&();
+  UnionMemberSeq *&ptr (void);
+  UnionMemberSeq *operator-> (void);
+  UnionMember &operator[] (CORBA::ULong index);
+  
+private:
+  UnionMemberSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const UnionMemberSeq_var &);
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_PRIMITIVEDEF___VAR_CH_)
-#define _CORBA_PRIMITIVEDEF___VAR_CH_
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMemberSeq;
 
-  class TAO_Export CORBA_PrimitiveDef_var
-  {
-  public:
-    CORBA_PrimitiveDef_var (void); // default constructor
-    CORBA_PrimitiveDef_var (CORBA_PrimitiveDef_ptr);
-    CORBA_PrimitiveDef_var (const CORBA_PrimitiveDef_var &); // copy constructor
-    ~CORBA_PrimitiveDef_var (void); // destructor
 
-    CORBA_PrimitiveDef_var &operator= (CORBA_PrimitiveDef_ptr);
-    CORBA_PrimitiveDef_var &operator= (const CORBA_PrimitiveDef_var &);
-    CORBA_PrimitiveDef_ptr operator-> (void) const;
+#if !defined (_IR_ENUMMEMBERSEQ_CH_)
+#define _IR_ENUMMEMBERSEQ_CH_
 
-    operator const CORBA_PrimitiveDef_ptr &() const;
-    operator CORBA_PrimitiveDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_PrimitiveDef_ptr in (void) const;
-    CORBA_PrimitiveDef_ptr &inout (void);
-    CORBA_PrimitiveDef_ptr &out (void);
-    CORBA_PrimitiveDef_ptr _retn (void);
-    CORBA_PrimitiveDef_ptr ptr (void) const;
+class EnumMemberSeq;
+class EnumMemberSeq_var;
 
-  private:
-    CORBA_PrimitiveDef_ptr ptr_;
-  };
+// *************************************************************
+// EnumMemberSeq
+// *************************************************************
+
+class TAO_Export EnumMemberSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  EnumMemberSeq (void); // default ctor
+  EnumMemberSeq (CORBA::ULong max); // uses max size
+  EnumMemberSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    char * *buffer, 
+    CORBA::Boolean release=0
+  );
+  EnumMemberSeq (const EnumMemberSeq &); // copy ctor
+  ~EnumMemberSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef EnumMemberSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_PRIMITIVEDEF___OUT_CH_)
-#define _CORBA_PRIMITIVEDEF___OUT_CH_
+#if !defined (_IR_ENUMMEMBERSEQ___VAR_CH_)
+#define _IR_ENUMMEMBERSEQ___VAR_CH_
 
-  class TAO_Export CORBA_PrimitiveDef_out
-  {
-  public:
-    CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_ptr &);
-    CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_var &);
-    CORBA_PrimitiveDef_out (const CORBA_PrimitiveDef_out &);
-    CORBA_PrimitiveDef_out &operator= (const CORBA_PrimitiveDef_out &);
-    CORBA_PrimitiveDef_out &operator= (const CORBA_PrimitiveDef_var &);
-    CORBA_PrimitiveDef_out &operator= (CORBA_PrimitiveDef_ptr);
-    operator CORBA_PrimitiveDef_ptr &();
-    CORBA_PrimitiveDef_ptr &ptr (void);
-    CORBA_PrimitiveDef_ptr operator-> (void);
+// *************************************************************
+// class IR::EnumMemberSeq_var
+// *************************************************************
 
-  private:
-    CORBA_PrimitiveDef_ptr &ptr_;
-  };
+class TAO_Export EnumMemberSeq_var
+{
+public:
+  EnumMemberSeq_var (void); // default constructor
+  EnumMemberSeq_var (EnumMemberSeq *);
+  EnumMemberSeq_var (const EnumMemberSeq_var &); // copy constructor
+  ~EnumMemberSeq_var (void); // destructor
+  
+  EnumMemberSeq_var &operator= (EnumMemberSeq *);
+  EnumMemberSeq_var &operator= (const EnumMemberSeq_var &);
+  EnumMemberSeq *operator-> (void);
+  const EnumMemberSeq *operator-> (void) const;
+  
+  operator const EnumMemberSeq &() const;
+  operator EnumMemberSeq &();
+  operator EnumMemberSeq &() const;
+  operator EnumMemberSeq *&(); // variable-size base types only
+  
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const EnumMemberSeq &in (void) const;
+  EnumMemberSeq &inout (void);
+  EnumMemberSeq *&out (void);
+  EnumMemberSeq *_retn (void);
+  EnumMemberSeq *ptr (void) const;
+
+private:
+  EnumMemberSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_STRINGDEF___VAR_CH_)
-#define _CORBA_STRINGDEF___VAR_CH_
 
-  class TAO_Export CORBA_StringDef_var
-  {
-  public:
-    CORBA_StringDef_var (void); // default constructor
-    CORBA_StringDef_var (CORBA_StringDef_ptr);
-    CORBA_StringDef_var (const CORBA_StringDef_var &); // copy constructor
-    ~CORBA_StringDef_var (void); // destructor
+#if !defined (_IR_ENUMMEMBERSEQ___OUT_CH_)
+#define _IR_ENUMMEMBERSEQ___OUT_CH_
+
+class TAO_Export EnumMemberSeq_out
+{
+public:
+  EnumMemberSeq_out (EnumMemberSeq *&);
+  EnumMemberSeq_out (EnumMemberSeq_var &);
+  EnumMemberSeq_out (const EnumMemberSeq_out &);
+  EnumMemberSeq_out &operator= (const EnumMemberSeq_out &);
+  EnumMemberSeq_out &operator= (EnumMemberSeq *);
+  operator EnumMemberSeq *&();
+  EnumMemberSeq *&ptr (void);
+  EnumMemberSeq *operator-> (void);
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  
+private:
+  EnumMemberSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const EnumMemberSeq_var &);
+};
 
-    CORBA_StringDef_var &operator= (CORBA_StringDef_ptr);
-    CORBA_StringDef_var &operator= (const CORBA_StringDef_var &);
-    CORBA_StringDef_ptr operator-> (void) const;
 
-    operator const CORBA_StringDef_ptr &() const;
-    operator CORBA_StringDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_StringDef_ptr in (void) const;
-    CORBA_StringDef_ptr &inout (void);
-    CORBA_StringDef_ptr &out (void);
-    CORBA_StringDef_ptr _retn (void);
-    CORBA_StringDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_StringDef_ptr ptr_;
-  };
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumMemberSeq;
+
+
+#if !defined (_IR_CONTAINER___PTR_CH_)
+#define _IR_CONTAINER___PTR_CH_
 
+class Container;
+typedef Container *Container_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRINGDEF___OUT_CH_)
-#define _CORBA_STRINGDEF___OUT_CH_
+#if !defined (_IR_CONTAINER___VAR_CH_)
+#define _IR_CONTAINER___VAR_CH_
+
+class TAO_Export Container_var
+{
+public:
+  Container_var (void); // default constructor
+  Container_var (Container_ptr);
+  Container_var (const Container_var &); // copy constructor
+  ~Container_var (void); // destructor
+  
+  Container_var &operator= (Container_ptr);
+  Container_var &operator= (const Container_var &);
+  Container_ptr operator-> (void) const;
+  
+  operator const Container_ptr &() const;
+  operator Container_ptr &();
+  // in, inout, out, _retn 
+  Container_ptr in (void) const;
+  Container_ptr &inout (void);
+  Container_ptr &out (void);
+  Container_ptr _retn (void);
+  Container_ptr ptr (void) const;
+
+private:
+  Container_ptr ptr_;
+};
 
-  class TAO_Export CORBA_StringDef_out
-  {
-  public:
-    CORBA_StringDef_out (CORBA_StringDef_ptr &);
-    CORBA_StringDef_out (CORBA_StringDef_var &);
-    CORBA_StringDef_out (const CORBA_StringDef_out &);
-    CORBA_StringDef_out &operator= (const CORBA_StringDef_out &);
-    CORBA_StringDef_out &operator= (const CORBA_StringDef_var &);
-    CORBA_StringDef_out &operator= (CORBA_StringDef_ptr);
-    operator CORBA_StringDef_ptr &();
-    CORBA_StringDef_ptr &ptr (void);
-    CORBA_StringDef_ptr operator-> (void);
 
-  private:
-    CORBA_StringDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONTAINER___OUT_CH_)
+#define _IR_CONTAINER___OUT_CH_
+
+class TAO_Export Container_out
+{
+public:
+  Container_out (Container_ptr &);
+  Container_out (Container_var &);
+  Container_out (const Container_out &);
+  Container_out &operator= (const Container_out &);
+  Container_out &operator= (const Container_var &);
+  Container_out &operator= (Container_ptr);
+  operator Container_ptr &();
+  Container_ptr &ptr (void);
+  Container_ptr operator-> (void);
+  
+private:
+  Container_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_SEQUENCEDEF___VAR_CH_)
-#define _CORBA_SEQUENCEDEF___VAR_CH_
 
-  class TAO_Export CORBA_SequenceDef_var
+#if !defined (_IR_CONTAINER_CH_)
+#define _IR_CONTAINER_CH_
+
+class TAO_Export Container: public virtual CORBA_IRObject
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef Container_ptr _ptr_type;
+  typedef Container_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static Container_ptr _duplicate (Container_ptr obj);
+  static Container_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static Container_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static Container_ptr _nil (void)
+    {
+      return (Container_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::Contained_ptr lookup (
+      const char * search_name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ContainedSeq * contents (
+      IR::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ContainedSeq * lookup_name (
+      const char * search_name,
+      CORBA::Long levels_to_search,
+      IR::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  struct Description;
+  class Description_var;
+  
+  struct TAO_Export Description
+  {
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef Description_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+    static void _tao_any_destructor (void*);
+
+    TAO_Object_Field_T<ACE_NESTED_CLASS (IR, Contained), ACE_NESTED_CLASS (IR, Contained_var)> contained_object;
+    ACE_NESTED_CLASS (IR, DefinitionKind) kind;
+    CORBA::Any value;
+  };
+
+  class TAO_Export Description_var
   {
   public:
-    CORBA_SequenceDef_var (void); // default constructor
-    CORBA_SequenceDef_var (CORBA_SequenceDef_ptr);
-    CORBA_SequenceDef_var (const CORBA_SequenceDef_var &); // copy constructor
-    ~CORBA_SequenceDef_var (void); // destructor
+    Description_var (void); // default constructor
+    Description_var (Description *);
+    Description_var (const Description_var &); // copy constructor
+    ~Description_var (void); // destructor
+    
+    Description_var &operator= (Description *);
+    Description_var &operator= (const Description_var &);
+    Description *operator-> (void);
+    const Description *operator-> (void) const;
+    
+    operator const Description &() const;
+    operator Description &();
+    operator Description &() const;
+    operator Description *&(); // variable-size types only
+    
+    // in, inout, out, _retn 
+    const Description &in (void) const;
+    Description &inout (void);
+    Description *&out (void);
+    Description *_retn (void);
+    Description *ptr (void) const;
 
-    CORBA_SequenceDef_var &operator= (CORBA_SequenceDef_ptr);
-    CORBA_SequenceDef_var &operator= (const CORBA_SequenceDef_var &);
-    CORBA_SequenceDef_ptr operator-> (void) const;
-
-    operator const CORBA_SequenceDef_ptr &() const;
-    operator CORBA_SequenceDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_SequenceDef_ptr in (void) const;
-    CORBA_SequenceDef_ptr &inout (void);
-    CORBA_SequenceDef_ptr &out (void);
-    CORBA_SequenceDef_ptr _retn (void);
-    CORBA_SequenceDef_ptr ptr (void) const;
+  private:
+    Description *ptr_;
+  };
 
+  class TAO_Export Description_out
+  {
+  public:
+    Description_out (Description *&);
+    Description_out (Description_var &);
+    Description_out (const Description_out &);
+    Description_out &operator= (const Description_out &);
+    Description_out &operator= (Description *);
+    operator Description *&();
+    Description *&ptr (void);
+    Description *operator-> (void);
+    
   private:
-    CORBA_SequenceDef_ptr ptr_;
+    Description *&ptr_;
+    // assignment from T_var not allowed
+    void operator= (const Description_var &);
   };
 
+  static CORBA::TypeCode_ptr _tc_Description;
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_CONTAINER_DESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_CONTAINER_DESCRIPTIONSEQ_CH_
+
+    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq : public TAO_Unbounded_Base_Sequence
+    {
+    public:
+      // = Initialization and termination methods.
+      
+      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (void); // Default constructor.
+      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (CORBA::ULong maximum); 
+      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (CORBA::ULong maximum,
+        CORBA::ULong length,
+        Description *data,
+        CORBA::Boolean release = 0);
+      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (const _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &rhs);
+      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &rhs);
+      virtual ~_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (void); // Dtor.
+      // = Accessors.
+      Description &operator[] (CORBA::ULong i);
+      const Description &operator[] (CORBA::ULong i) const;
+      // = Static operations.
+      static Description *allocbuf (CORBA::ULong size);
+      static void freebuf (Description *buffer);
+      virtual void _allocate_buffer (CORBA::ULong length);
+      virtual void _deallocate_buffer (void);
+      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+      
+      Description *get_buffer (CORBA::Boolean orphan = 0);
+      const Description *get_buffer (void) const;
+      void replace (CORBA::ULong max,
+        CORBA::ULong length,
+        Description *data,
+        CORBA::Boolean release);
+    };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_SEQUENCEDEF___OUT_CH_)
-#define _CORBA_SEQUENCEDEF___OUT_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+  
+#if !defined (_IR_CONTAINER_DESCRIPTIONSEQ_CH_)
+#define _IR_CONTAINER_DESCRIPTIONSEQ_CH_
 
-  class TAO_Export CORBA_SequenceDef_out
+  class DescriptionSeq;
+  class DescriptionSeq_var;
+  
+  // *************************************************************
+  // DescriptionSeq
+  // *************************************************************
+  
+  class TAO_Export DescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+    _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+    TAO_Unbounded_Sequence<Description>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
   {
   public:
-    CORBA_SequenceDef_out (CORBA_SequenceDef_ptr &);
-    CORBA_SequenceDef_out (CORBA_SequenceDef_var &);
-    CORBA_SequenceDef_out (const CORBA_SequenceDef_out &);
-    CORBA_SequenceDef_out &operator= (const CORBA_SequenceDef_out &);
-    CORBA_SequenceDef_out &operator= (const CORBA_SequenceDef_var &);
-    CORBA_SequenceDef_out &operator= (CORBA_SequenceDef_ptr);
-    operator CORBA_SequenceDef_ptr &();
-    CORBA_SequenceDef_ptr &ptr (void);
-    CORBA_SequenceDef_ptr operator-> (void);
+    DescriptionSeq (void); // default ctor
+    DescriptionSeq (CORBA::ULong max); // uses max size
+    DescriptionSeq (
+      CORBA::ULong max, 
+      CORBA::ULong length, 
+      Description *buffer, 
+      CORBA::Boolean release=0
+    );
+    DescriptionSeq (const DescriptionSeq &); // copy ctor
+    ~DescriptionSeq (void);
+    static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef DescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  private:
-    CORBA_SequenceDef_ptr &ptr_;
   };
 
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONTAINER_DESCRIPTIONSEQ___VAR_CH_)
+#define _IR_CONTAINER_DESCRIPTIONSEQ___VAR_CH_
+
+// *************************************************************
+// class IR::Container::DescriptionSeq_var
+// *************************************************************
+
+class TAO_Export DescriptionSeq_var
+{
+public:
+  DescriptionSeq_var (void); // default constructor
+  DescriptionSeq_var (DescriptionSeq *);
+  DescriptionSeq_var (const DescriptionSeq_var &); // copy constructor
+  ~DescriptionSeq_var (void); // destructor
+  
+  DescriptionSeq_var &operator= (DescriptionSeq *);
+  DescriptionSeq_var &operator= (const DescriptionSeq_var &);
+  DescriptionSeq *operator-> (void);
+  const DescriptionSeq *operator-> (void) const;
+  
+  operator const DescriptionSeq &() const;
+  operator DescriptionSeq &();
+  operator DescriptionSeq &() const;
+  operator DescriptionSeq *&(); // variable-size base types only
+  
+  Description &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const DescriptionSeq &in (void) const;
+  DescriptionSeq &inout (void);
+  DescriptionSeq *&out (void);
+  DescriptionSeq *_retn (void);
+  DescriptionSeq *ptr (void) const;
+
+private:
+  DescriptionSeq *ptr_;
+};
+
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_ARRAYDEF___VAR_CH_)
-#define _CORBA_ARRAYDEF___VAR_CH_
 
-  class TAO_Export CORBA_ArrayDef_var
+#if !defined (_IR_CONTAINER_DESCRIPTIONSEQ___OUT_CH_)
+#define _IR_CONTAINER_DESCRIPTIONSEQ___OUT_CH_
+
+class TAO_Export DescriptionSeq_out
+{
+public:
+  DescriptionSeq_out (DescriptionSeq *&);
+  DescriptionSeq_out (DescriptionSeq_var &);
+  DescriptionSeq_out (const DescriptionSeq_out &);
+  DescriptionSeq_out &operator= (const DescriptionSeq_out &);
+  DescriptionSeq_out &operator= (DescriptionSeq *);
+  operator DescriptionSeq *&();
+  DescriptionSeq *&ptr (void);
+  DescriptionSeq *operator-> (void);
+  Description &operator[] (CORBA::ULong index);
+  
+private:
+  DescriptionSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const DescriptionSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+static CORBA::TypeCode_ptr _tc_DescriptionSeq;
+
+virtual IR::Container::DescriptionSeq * describe_contents (
+    IR::DefinitionKind limit_type,
+    CORBA::Boolean exclude_inherited,
+    CORBA::Long max_returned_objs,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::ModuleDef_ptr create_module (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::ConstantDef_ptr create_constant (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr type,
+    const CORBA::Any & value,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::StructDef_ptr create_struct (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::UnionDef_ptr create_union (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr discriminator_type,
+    const IR::UnionMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::EnumDef_ptr create_enum (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::EnumMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::AliasDef_ptr create_alias (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr original_type,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::InterfaceDef_ptr create_interface (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::InterfaceDefSeq & base_interfaces,
+    CORBA::Boolean is_abstract,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::ValueDef_ptr create_value (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Boolean is_custom,
+    CORBA::Boolean is_abstract,
+    IR::ValueDef_ptr base_value,
+    CORBA::Boolean is_truncatable,
+    const IR::ValueDefSeq & abstract_base_values,
+    const IR::InterfaceDefSeq & supported_interfaces,
+    const IR::InitializerSeq & initializers,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::ValueBoxDef_ptr create_value_box (
+    const char * id,
+    const char * name,
+    const char * version,
+    IR::IDLType_ptr original_type_def,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::ExceptionDef_ptr create_exception (
+    const char * id,
+    const char * name,
+    const char * version,
+    const IR::StructMemberSeq & members,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual IR::NativeDef_ptr create_native (
+    const char * id,
+    const char * name,
+    const char * version,
+    CORBA::Environment &ACE_TRY_ENV = 
+      TAO_default_environment ()
+  )
+  ACE_THROW_SPEC ((
+    CORBA::SystemException
+  ));
+
+virtual CORBA::Boolean _is_a (
+    const CORBA::Char *type_id, 
+    CORBA::Environment &env = 
+      TAO_default_environment ()
+  );
+virtual const char* _interface_repository_id (void) const;
+
+protected:
+  Container (void);
+  Container (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~Container (void);
+private:
+  Container (const Container &);
+  void operator= (const Container &);
+};
+
+class TAO_IR_Container_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_Container_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_Container_Default_Proxy_Factory (void);
+  
+  virtual Container_ptr create_proxy (
+      Container_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_Container_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_Container_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_Container_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  Container_ptr create_proxy (
+      Container_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_Container_Proxy_Factory_Adapter (void);
+  ~TAO_IR_Container_Proxy_Factory_Adapter (void);
+  TAO_IR_Container_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_Container_Proxy_Factory_Adapter &
+    );
+  TAO_IR_Container_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_Container_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_Container_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_Container_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, Container)
   {
   public:
-    CORBA_ArrayDef_var (void); // default constructor
-    CORBA_ArrayDef_var (CORBA_ArrayDef_ptr);
-    CORBA_ArrayDef_var (const CORBA_ArrayDef_var &); // copy constructor
-    ~CORBA_ArrayDef_var (void); // destructor
+    TAO_IR_Container_Smart_Proxy_Base (::IR::Container_ptr proxy);
+    ~TAO_IR_Container_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::Contained_ptr lookup (
+      const char * search_name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ContainedSeq * contents (
+      IR::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ContainedSeq * lookup_name (
+      const char * search_name,
+      CORBA::Long levels_to_search,
+      IR::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::Container::DescriptionSeq * describe_contents (
+      IR::DefinitionKind limit_type,
+      CORBA::Boolean exclude_inherited,
+      CORBA::Long max_returned_objs,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ModuleDef_ptr create_module (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ConstantDef_ptr create_constant (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr type,
+      const CORBA::Any & value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::StructDef_ptr create_struct (
+      const char * id,
+      const char * name,
+      const char * version,
+      const IR::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::UnionDef_ptr create_union (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr discriminator_type,
+      const IR::UnionMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::EnumDef_ptr create_enum (
+      const char * id,
+      const char * name,
+      const char * version,
+      const IR::EnumMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::AliasDef_ptr create_alias (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr original_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::InterfaceDef_ptr create_interface (
+      const char * id,
+      const char * name,
+      const char * version,
+      const IR::InterfaceDefSeq & base_interfaces,
+      CORBA::Boolean is_abstract,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueDef_ptr create_value (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Boolean is_custom,
+      CORBA::Boolean is_abstract,
+      IR::ValueDef_ptr base_value,
+      CORBA::Boolean is_truncatable,
+      const IR::ValueDefSeq & abstract_base_values,
+      const IR::InterfaceDefSeq & supported_interfaces,
+      const IR::InitializerSeq & initializers,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueBoxDef_ptr create_value_box (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ExceptionDef_ptr create_exception (
+      const char * id,
+      const char * name,
+      const char * version,
+      const IR::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::NativeDef_ptr create_native (
+      const char * id,
+      const char * name,
+      const char * version,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::Container_var base_proxy_;
+};
 
-    CORBA_ArrayDef_var &operator= (CORBA_ArrayDef_ptr);
-    CORBA_ArrayDef_var &operator= (const CORBA_ArrayDef_var &);
-    CORBA_ArrayDef_ptr operator-> (void) const;
 
-    operator const CORBA_ArrayDef_ptr &() const;
-    operator CORBA_ArrayDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ArrayDef_ptr in (void) const;
-    CORBA_ArrayDef_ptr &inout (void);
-    CORBA_ArrayDef_ptr &out (void);
-    CORBA_ArrayDef_ptr _retn (void);
-    CORBA_ArrayDef_ptr ptr (void) const;
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Container;
 
-  private:
-    CORBA_ArrayDef_ptr ptr_;
-  };
 
+#if !defined (_IR_IDLTYPE___PTR_CH_)
+#define _IR_IDLTYPE___PTR_CH_
+
+class IDLType;
+typedef IDLType *IDLType_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ARRAYDEF___OUT_CH_)
-#define _CORBA_ARRAYDEF___OUT_CH_
+#if !defined (_IR_IDLTYPE___VAR_CH_)
+#define _IR_IDLTYPE___VAR_CH_
+
+class TAO_Export IDLType_var
+{
+public:
+  IDLType_var (void); // default constructor
+  IDLType_var (IDLType_ptr);
+  IDLType_var (const IDLType_var &); // copy constructor
+  ~IDLType_var (void); // destructor
+  
+  IDLType_var &operator= (IDLType_ptr);
+  IDLType_var &operator= (const IDLType_var &);
+  IDLType_ptr operator-> (void) const;
+  
+  operator const IDLType_ptr &() const;
+  operator IDLType_ptr &();
+  // in, inout, out, _retn 
+  IDLType_ptr in (void) const;
+  IDLType_ptr &inout (void);
+  IDLType_ptr &out (void);
+  IDLType_ptr _retn (void);
+  IDLType_ptr ptr (void) const;
+
+private:
+  IDLType_ptr ptr_;
+};
 
-  class TAO_Export CORBA_ArrayDef_out
-  {
-  public:
-    CORBA_ArrayDef_out (CORBA_ArrayDef_ptr &);
-    CORBA_ArrayDef_out (CORBA_ArrayDef_var &);
-    CORBA_ArrayDef_out (const CORBA_ArrayDef_out &);
-    CORBA_ArrayDef_out &operator= (const CORBA_ArrayDef_out &);
-    CORBA_ArrayDef_out &operator= (const CORBA_ArrayDef_var &);
-    CORBA_ArrayDef_out &operator= (CORBA_ArrayDef_ptr);
-    operator CORBA_ArrayDef_ptr &();
-    CORBA_ArrayDef_ptr &ptr (void);
-    CORBA_ArrayDef_ptr operator-> (void);
 
-  private:
-    CORBA_ArrayDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_IDLTYPE___OUT_CH_)
+#define _IR_IDLTYPE___OUT_CH_
+
+class TAO_Export IDLType_out
+{
+public:
+  IDLType_out (IDLType_ptr &);
+  IDLType_out (IDLType_var &);
+  IDLType_out (const IDLType_out &);
+  IDLType_out &operator= (const IDLType_out &);
+  IDLType_out &operator= (const IDLType_var &);
+  IDLType_out &operator= (IDLType_ptr);
+  operator IDLType_ptr &();
+  IDLType_ptr &ptr (void);
+  IDLType_ptr operator-> (void);
+  
+private:
+  IDLType_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_WSTRINGDEF___VAR_CH_)
-#define _CORBA_WSTRINGDEF___VAR_CH_
 
-  class TAO_Export CORBA_WstringDef_var
+#if !defined (_IR_IDLTYPE_CH_)
+#define _IR_IDLTYPE_CH_
+
+class TAO_Export IDLType: public virtual CORBA_IRObject
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef IDLType_ptr _ptr_type;
+  typedef IDLType_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static IDLType_ptr _duplicate (IDLType_ptr obj);
+  static IDLType_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static IDLType_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static IDLType_ptr _nil (void)
+    {
+      return (IDLType_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  IDLType (void);
+  IDLType (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~IDLType (void);
+private:
+  IDLType (const IDLType &);
+  void operator= (const IDLType &);
+};
+
+class TAO_IR_IDLType_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_IDLType_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_IDLType_Default_Proxy_Factory (void);
+  
+  virtual IDLType_ptr create_proxy (
+      IDLType_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_IDLType_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_IDLType_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_IDLType_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  IDLType_ptr create_proxy (
+      IDLType_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_IDLType_Proxy_Factory_Adapter (void);
+  ~TAO_IR_IDLType_Proxy_Factory_Adapter (void);
+  TAO_IR_IDLType_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_IDLType_Proxy_Factory_Adapter &
+    );
+  TAO_IR_IDLType_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_IDLType_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_IDLType_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_IDLType_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, IDLType)
   {
   public:
-    CORBA_WstringDef_var (void); // default constructor
-    CORBA_WstringDef_var (CORBA_WstringDef_ptr);
-    CORBA_WstringDef_var (const CORBA_WstringDef_var &); // copy constructor
-    ~CORBA_WstringDef_var (void); // destructor
+    TAO_IR_IDLType_Smart_Proxy_Base (::IR::IDLType_ptr proxy);
+    ~TAO_IR_IDLType_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::IDLType_var base_proxy_;
+};
 
-    CORBA_WstringDef_var &operator= (CORBA_WstringDef_ptr);
-    CORBA_WstringDef_var &operator= (const CORBA_WstringDef_var &);
-    CORBA_WstringDef_ptr operator-> (void) const;
 
-    operator const CORBA_WstringDef_ptr &() const;
-    operator CORBA_WstringDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_WstringDef_ptr in (void) const;
-    CORBA_WstringDef_ptr &inout (void);
-    CORBA_WstringDef_ptr &out (void);
-    CORBA_WstringDef_ptr _retn (void);
-    CORBA_WstringDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_WstringDef_ptr ptr_;
-  };
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IDLType;
+
+class PrimitiveDef;
 
+#if !defined (_IR_PRIMITIVEDEF___PTR_CH_)
+#define _IR_PRIMITIVEDEF___PTR_CH_
+
+typedef PrimitiveDef *PrimitiveDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_WSTRINGDEF___OUT_CH_)
-#define _CORBA_WSTRINGDEF___OUT_CH_
+#if !defined (_IR_PRIMITIVEDEF___VAR_CH_)
+#define _IR_PRIMITIVEDEF___VAR_CH_
+
+class TAO_Export PrimitiveDef_var
+{
+public:
+  PrimitiveDef_var (void); // default constructor
+  PrimitiveDef_var (PrimitiveDef_ptr);
+  PrimitiveDef_var (const PrimitiveDef_var &); // copy constructor
+  ~PrimitiveDef_var (void); // destructor
+  
+  PrimitiveDef_var &operator= (PrimitiveDef_ptr);
+  PrimitiveDef_var &operator= (const PrimitiveDef_var &);
+  PrimitiveDef_ptr operator-> (void) const;
+  
+  operator const PrimitiveDef_ptr &() const;
+  operator PrimitiveDef_ptr &();
+  // in, inout, out, _retn 
+  PrimitiveDef_ptr in (void) const;
+  PrimitiveDef_ptr &inout (void);
+  PrimitiveDef_ptr &out (void);
+  PrimitiveDef_ptr _retn (void);
+  PrimitiveDef_ptr ptr (void) const;
+
+private:
+  PrimitiveDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_WstringDef_out
-  {
-  public:
-    CORBA_WstringDef_out (CORBA_WstringDef_ptr &);
-    CORBA_WstringDef_out (CORBA_WstringDef_var &);
-    CORBA_WstringDef_out (const CORBA_WstringDef_out &);
-    CORBA_WstringDef_out &operator= (const CORBA_WstringDef_out &);
-    CORBA_WstringDef_out &operator= (const CORBA_WstringDef_var &);
-    CORBA_WstringDef_out &operator= (CORBA_WstringDef_ptr);
-    operator CORBA_WstringDef_ptr &();
-    CORBA_WstringDef_ptr &ptr (void);
-    CORBA_WstringDef_ptr operator-> (void);
 
-  private:
-    CORBA_WstringDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMITIVEDEF___OUT_CH_)
+#define _IR_PRIMITIVEDEF___OUT_CH_
+
+class TAO_Export PrimitiveDef_out
+{
+public:
+  PrimitiveDef_out (PrimitiveDef_ptr &);
+  PrimitiveDef_out (PrimitiveDef_var &);
+  PrimitiveDef_out (const PrimitiveDef_out &);
+  PrimitiveDef_out &operator= (const PrimitiveDef_out &);
+  PrimitiveDef_out &operator= (const PrimitiveDef_var &);
+  PrimitiveDef_out &operator= (PrimitiveDef_ptr);
+  operator PrimitiveDef_ptr &();
+  PrimitiveDef_ptr &ptr (void);
+  PrimitiveDef_ptr operator-> (void);
+  
+private:
+  PrimitiveDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_FIXEDDEF___VAR_CH_)
-#define _CORBA_FIXEDDEF___VAR_CH_
+class StringDef;
 
-  class TAO_Export CORBA_FixedDef_var
-  {
-  public:
-    CORBA_FixedDef_var (void); // default constructor
-    CORBA_FixedDef_var (CORBA_FixedDef_ptr);
-    CORBA_FixedDef_var (const CORBA_FixedDef_var &); // copy constructor
-    ~CORBA_FixedDef_var (void); // destructor
+#if !defined (_IR_STRINGDEF___PTR_CH_)
+#define _IR_STRINGDEF___PTR_CH_
 
-    CORBA_FixedDef_var &operator= (CORBA_FixedDef_ptr);
-    CORBA_FixedDef_var &operator= (const CORBA_FixedDef_var &);
-    CORBA_FixedDef_ptr operator-> (void) const;
+typedef StringDef *StringDef_ptr;
 
-    operator const CORBA_FixedDef_ptr &() const;
-    operator CORBA_FixedDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_FixedDef_ptr in (void) const;
-    CORBA_FixedDef_ptr &inout (void);
-    CORBA_FixedDef_ptr &out (void);
-    CORBA_FixedDef_ptr _retn (void);
-    CORBA_FixedDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_FixedDef_ptr ptr_;
-  };
+
+#if !defined (_IR_STRINGDEF___VAR_CH_)
+#define _IR_STRINGDEF___VAR_CH_
+
+class TAO_Export StringDef_var
+{
+public:
+  StringDef_var (void); // default constructor
+  StringDef_var (StringDef_ptr);
+  StringDef_var (const StringDef_var &); // copy constructor
+  ~StringDef_var (void); // destructor
+  
+  StringDef_var &operator= (StringDef_ptr);
+  StringDef_var &operator= (const StringDef_var &);
+  StringDef_ptr operator-> (void) const;
+  
+  operator const StringDef_ptr &() const;
+  operator StringDef_ptr &();
+  // in, inout, out, _retn 
+  StringDef_ptr in (void) const;
+  StringDef_ptr &inout (void);
+  StringDef_ptr &out (void);
+  StringDef_ptr _retn (void);
+  StringDef_ptr ptr (void) const;
+
+private:
+  StringDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_FIXEDDEF___OUT_CH_)
-#define _CORBA_FIXEDDEF___OUT_CH_
+#if !defined (_IR_STRINGDEF___OUT_CH_)
+#define _IR_STRINGDEF___OUT_CH_
 
-  class TAO_Export CORBA_FixedDef_out
-  {
-  public:
-    CORBA_FixedDef_out (CORBA_FixedDef_ptr &);
-    CORBA_FixedDef_out (CORBA_FixedDef_var &);
-    CORBA_FixedDef_out (const CORBA_FixedDef_out &);
-    CORBA_FixedDef_out &operator= (const CORBA_FixedDef_out &);
-    CORBA_FixedDef_out &operator= (const CORBA_FixedDef_var &);
-    CORBA_FixedDef_out &operator= (CORBA_FixedDef_ptr);
-    operator CORBA_FixedDef_ptr &();
-    CORBA_FixedDef_ptr &ptr (void);
-    CORBA_FixedDef_ptr operator-> (void);
+class TAO_Export StringDef_out
+{
+public:
+  StringDef_out (StringDef_ptr &);
+  StringDef_out (StringDef_var &);
+  StringDef_out (const StringDef_out &);
+  StringDef_out &operator= (const StringDef_out &);
+  StringDef_out &operator= (const StringDef_var &);
+  StringDef_out &operator= (StringDef_ptr);
+  operator StringDef_ptr &();
+  StringDef_ptr &ptr (void);
+  StringDef_ptr operator-> (void);
+  
+private:
+  StringDef_ptr &ptr_;
+};
 
-  private:
-    CORBA_FixedDef_ptr &ptr_;
-  };
 
+#endif /* end #if !defined */
+
+class SequenceDef;
+
+#if !defined (_IR_SEQUENCEDEF___PTR_CH_)
+#define _IR_SEQUENCEDEF___PTR_CH_
+
+typedef SequenceDef *SequenceDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_REPOSITORY___VAR_CH_)
-#define _CORBA_REPOSITORY___VAR_CH_
+#if !defined (_IR_SEQUENCEDEF___VAR_CH_)
+#define _IR_SEQUENCEDEF___VAR_CH_
+
+class TAO_Export SequenceDef_var
+{
+public:
+  SequenceDef_var (void); // default constructor
+  SequenceDef_var (SequenceDef_ptr);
+  SequenceDef_var (const SequenceDef_var &); // copy constructor
+  ~SequenceDef_var (void); // destructor
+  
+  SequenceDef_var &operator= (SequenceDef_ptr);
+  SequenceDef_var &operator= (const SequenceDef_var &);
+  SequenceDef_ptr operator-> (void) const;
+  
+  operator const SequenceDef_ptr &() const;
+  operator SequenceDef_ptr &();
+  // in, inout, out, _retn 
+  SequenceDef_ptr in (void) const;
+  SequenceDef_ptr &inout (void);
+  SequenceDef_ptr &out (void);
+  SequenceDef_ptr _retn (void);
+  SequenceDef_ptr ptr (void) const;
+
+private:
+  SequenceDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_Repository_var
-  {
-  public:
-    CORBA_Repository_var (void); // default constructor
-    CORBA_Repository_var (CORBA_Repository_ptr);
-    CORBA_Repository_var (const CORBA_Repository_var &); // copy constructor
-    ~CORBA_Repository_var (void); // destructor
 
-    CORBA_Repository_var &operator= (CORBA_Repository_ptr);
-    CORBA_Repository_var &operator= (const CORBA_Repository_var &);
-    CORBA_Repository_ptr operator-> (void) const;
+#endif /* end #if !defined */
 
-    operator const CORBA_Repository_ptr &() const;
-    operator CORBA_Repository_ptr &();
-    // in, inout, out, _retn
-    CORBA_Repository_ptr in (void) const;
-    CORBA_Repository_ptr &inout (void);
-    CORBA_Repository_ptr &out (void);
-    CORBA_Repository_ptr _retn (void);
-    CORBA_Repository_ptr ptr (void) const;
 
-  private:
-    CORBA_Repository_ptr ptr_;
-  };
+#if !defined (_IR_SEQUENCEDEF___OUT_CH_)
+#define _IR_SEQUENCEDEF___OUT_CH_
+
+class TAO_Export SequenceDef_out
+{
+public:
+  SequenceDef_out (SequenceDef_ptr &);
+  SequenceDef_out (SequenceDef_var &);
+  SequenceDef_out (const SequenceDef_out &);
+  SequenceDef_out &operator= (const SequenceDef_out &);
+  SequenceDef_out &operator= (const SequenceDef_var &);
+  SequenceDef_out &operator= (SequenceDef_ptr);
+  operator SequenceDef_ptr &();
+  SequenceDef_ptr &ptr (void);
+  SequenceDef_ptr operator-> (void);
+  
+private:
+  SequenceDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
+class ArrayDef;
 
-#if !defined (_CORBA_REPOSITORY___OUT_CH_)
-#define _CORBA_REPOSITORY___OUT_CH_
+#if !defined (_IR_ARRAYDEF___PTR_CH_)
+#define _IR_ARRAYDEF___PTR_CH_
 
-  class TAO_Export CORBA_Repository_out
-  {
-  public:
-    CORBA_Repository_out (CORBA_Repository_ptr &);
-    CORBA_Repository_out (CORBA_Repository_var &);
-    CORBA_Repository_out (const CORBA_Repository_out &);
-    CORBA_Repository_out &operator= (const CORBA_Repository_out &);
-    CORBA_Repository_out &operator= (const CORBA_Repository_var &);
-    CORBA_Repository_out &operator= (CORBA_Repository_ptr);
-    operator CORBA_Repository_ptr &();
-    CORBA_Repository_ptr &ptr (void);
-    CORBA_Repository_ptr operator-> (void);
+typedef ArrayDef *ArrayDef_ptr;
+
+#endif /* end #if !defined */
 
-  private:
-    CORBA_Repository_ptr &ptr_;
-  };
+
+#if !defined (_IR_ARRAYDEF___VAR_CH_)
+#define _IR_ARRAYDEF___VAR_CH_
+
+class TAO_Export ArrayDef_var
+{
+public:
+  ArrayDef_var (void); // default constructor
+  ArrayDef_var (ArrayDef_ptr);
+  ArrayDef_var (const ArrayDef_var &); // copy constructor
+  ~ArrayDef_var (void); // destructor
+  
+  ArrayDef_var &operator= (ArrayDef_ptr);
+  ArrayDef_var &operator= (const ArrayDef_var &);
+  ArrayDef_ptr operator-> (void) const;
+  
+  operator const ArrayDef_ptr &() const;
+  operator ArrayDef_ptr &();
+  // in, inout, out, _retn 
+  ArrayDef_ptr in (void) const;
+  ArrayDef_ptr &inout (void);
+  ArrayDef_ptr &out (void);
+  ArrayDef_ptr _retn (void);
+  ArrayDef_ptr ptr (void) const;
+
+private:
+  ArrayDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_REPOSITORY_CH_)
-#define _CORBA_REPOSITORY_CH_
+#if !defined (_IR_ARRAYDEF___OUT_CH_)
+#define _IR_ARRAYDEF___OUT_CH_
 
-class TAO_Export CORBA_Repository: public virtual CORBA_Container
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_Repository_ptr _ptr_type;
-    typedef CORBA_Repository_var _var_type;
-  #endif /* __GNUC__ */
+class TAO_Export ArrayDef_out
+{
+public:
+  ArrayDef_out (ArrayDef_ptr &);
+  ArrayDef_out (ArrayDef_var &);
+  ArrayDef_out (const ArrayDef_out &);
+  ArrayDef_out &operator= (const ArrayDef_out &);
+  ArrayDef_out &operator= (const ArrayDef_var &);
+  ArrayDef_out &operator= (ArrayDef_ptr);
+  operator ArrayDef_ptr &();
+  ArrayDef_ptr &ptr (void);
+  ArrayDef_ptr operator-> (void);
+  
+private:
+  ArrayDef_ptr &ptr_;
+};
 
-    // the static operations
-    static CORBA_Repository_ptr _duplicate (CORBA_Repository_ptr obj);
-    static CORBA_Repository_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_Repository_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_Repository_ptr _nil (void)
-      {
-        return (CORBA::Repository_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA_Contained_ptr lookup_id (
-        const char * search_id,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_PrimitiveDef_ptr get_primitive (
-        CORBA::PrimitiveKind kind,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+class WstringDef;
 
-    virtual CORBA_StringDef_ptr create_string (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_WSTRINGDEF___PTR_CH_)
+#define _IR_WSTRINGDEF___PTR_CH_
 
-    virtual CORBA_WstringDef_ptr create_wstring (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+typedef WstringDef *WstringDef_ptr;
 
-    virtual CORBA_SequenceDef_ptr create_sequence (
-        CORBA::ULong bound,
-        CORBA_IDLType_ptr element_type,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_ArrayDef_ptr create_array (
-        CORBA::ULong length,
-        CORBA_IDLType_ptr element_type,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_FixedDef_ptr create_fixed (
-        CORBA::UShort digits,
-        CORBA::Short scale,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_WSTRINGDEF___VAR_CH_)
+#define _IR_WSTRINGDEF___VAR_CH_
+
+class TAO_Export WstringDef_var
+{
+public:
+  WstringDef_var (void); // default constructor
+  WstringDef_var (WstringDef_ptr);
+  WstringDef_var (const WstringDef_var &); // copy constructor
+  ~WstringDef_var (void); // destructor
+  
+  WstringDef_var &operator= (WstringDef_ptr);
+  WstringDef_var &operator= (const WstringDef_var &);
+  WstringDef_ptr operator-> (void) const;
+  
+  operator const WstringDef_ptr &() const;
+  operator WstringDef_ptr &();
+  // in, inout, out, _retn 
+  WstringDef_ptr in (void) const;
+  WstringDef_ptr &inout (void);
+  WstringDef_ptr &out (void);
+  WstringDef_ptr _retn (void);
+  WstringDef_ptr ptr (void) const;
+
+private:
+  WstringDef_ptr ptr_;
+};
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
 
-  protected:
-    CORBA_Repository (void);
-    CORBA_Repository (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_Repository (void);
-  private:
-    CORBA_Repository (const CORBA_Repository &);
-    void operator= (const CORBA_Repository &);
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_WSTRINGDEF___OUT_CH_)
+#define _IR_WSTRINGDEF___OUT_CH_
+
+class TAO_Export WstringDef_out
+{
+public:
+  WstringDef_out (WstringDef_ptr &);
+  WstringDef_out (WstringDef_var &);
+  WstringDef_out (const WstringDef_out &);
+  WstringDef_out &operator= (const WstringDef_out &);
+  WstringDef_out &operator= (const WstringDef_var &);
+  WstringDef_out &operator= (WstringDef_ptr);
+  operator WstringDef_ptr &();
+  WstringDef_ptr &ptr (void);
+  WstringDef_ptr operator-> (void);
+  
+private:
+  WstringDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_MODULEDEF___VAR_CH_)
-#define _CORBA_MODULEDEF___VAR_CH_
+class FixedDef;
 
-  class TAO_Export CORBA_ModuleDef_var
-  {
-  public:
-    CORBA_ModuleDef_var (void); // default constructor
-    CORBA_ModuleDef_var (CORBA_ModuleDef_ptr);
-    CORBA_ModuleDef_var (const CORBA_ModuleDef_var &); // copy constructor
-    ~CORBA_ModuleDef_var (void); // destructor
+#if !defined (_IR_FIXEDDEF___PTR_CH_)
+#define _IR_FIXEDDEF___PTR_CH_
 
-    CORBA_ModuleDef_var &operator= (CORBA_ModuleDef_ptr);
-    CORBA_ModuleDef_var &operator= (const CORBA_ModuleDef_var &);
-    CORBA_ModuleDef_ptr operator-> (void) const;
+typedef FixedDef *FixedDef_ptr;
 
-    operator const CORBA_ModuleDef_ptr &() const;
-    operator CORBA_ModuleDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ModuleDef_ptr in (void) const;
-    CORBA_ModuleDef_ptr &inout (void);
-    CORBA_ModuleDef_ptr &out (void);
-    CORBA_ModuleDef_ptr _retn (void);
-    CORBA_ModuleDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_ModuleDef_ptr ptr_;
-  };
+
+#if !defined (_IR_FIXEDDEF___VAR_CH_)
+#define _IR_FIXEDDEF___VAR_CH_
+
+class TAO_Export FixedDef_var
+{
+public:
+  FixedDef_var (void); // default constructor
+  FixedDef_var (FixedDef_ptr);
+  FixedDef_var (const FixedDef_var &); // copy constructor
+  ~FixedDef_var (void); // destructor
+  
+  FixedDef_var &operator= (FixedDef_ptr);
+  FixedDef_var &operator= (const FixedDef_var &);
+  FixedDef_ptr operator-> (void) const;
+  
+  operator const FixedDef_ptr &() const;
+  operator FixedDef_ptr &();
+  // in, inout, out, _retn 
+  FixedDef_ptr in (void) const;
+  FixedDef_ptr &inout (void);
+  FixedDef_ptr &out (void);
+  FixedDef_ptr _retn (void);
+  FixedDef_ptr ptr (void) const;
+
+private:
+  FixedDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_MODULEDEF___OUT_CH_)
-#define _CORBA_MODULEDEF___OUT_CH_
+#if !defined (_IR_FIXEDDEF___OUT_CH_)
+#define _IR_FIXEDDEF___OUT_CH_
 
-  class TAO_Export CORBA_ModuleDef_out
-  {
-  public:
-    CORBA_ModuleDef_out (CORBA_ModuleDef_ptr &);
-    CORBA_ModuleDef_out (CORBA_ModuleDef_var &);
-    CORBA_ModuleDef_out (const CORBA_ModuleDef_out &);
-    CORBA_ModuleDef_out &operator= (const CORBA_ModuleDef_out &);
-    CORBA_ModuleDef_out &operator= (const CORBA_ModuleDef_var &);
-    CORBA_ModuleDef_out &operator= (CORBA_ModuleDef_ptr);
-    operator CORBA_ModuleDef_ptr &();
-    CORBA_ModuleDef_ptr &ptr (void);
-    CORBA_ModuleDef_ptr operator-> (void);
+class TAO_Export FixedDef_out
+{
+public:
+  FixedDef_out (FixedDef_ptr &);
+  FixedDef_out (FixedDef_var &);
+  FixedDef_out (const FixedDef_out &);
+  FixedDef_out &operator= (const FixedDef_out &);
+  FixedDef_out &operator= (const FixedDef_var &);
+  FixedDef_out &operator= (FixedDef_ptr);
+  operator FixedDef_ptr &();
+  FixedDef_ptr &ptr (void);
+  FixedDef_ptr operator-> (void);
+  
+private:
+  FixedDef_ptr &ptr_;
+};
 
-  private:
-    CORBA_ModuleDef_ptr &ptr_;
-  };
 
+#endif /* end #if !defined */
+
+enum PrimitiveKind
+{
+    pk_null,
+    pk_void,
+    pk_short,
+    pk_long,
+    pk_ushort,
+    pk_ulong,
+    pk_float,
+    pk_double,
+    pk_boolean,
+    pk_char,
+    pk_octet,
+    pk_any,
+    pk_TypeCode,
+    pk_Principal,
+    pk_string,
+    pk_objref,
+    pk_longlong,
+    pk_ulonglong,
+    pk_longdouble,
+    pk_wchar,
+    pk_wstring,
+    pk_value_base,
+    PrimitiveKind_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF
+};
+typedef PrimitiveKind &PrimitiveKind_out;
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveKind;
+
+
+#if !defined (_IR_REPOSITORY___PTR_CH_)
+#define _IR_REPOSITORY___PTR_CH_
+
+class Repository;
+typedef Repository *Repository_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_MODULEDEF_CH_)
-#define _CORBA_MODULEDEF_CH_
+#if !defined (_IR_REPOSITORY___VAR_CH_)
+#define _IR_REPOSITORY___VAR_CH_
+
+class TAO_Export Repository_var
+{
+public:
+  Repository_var (void); // default constructor
+  Repository_var (Repository_ptr);
+  Repository_var (const Repository_var &); // copy constructor
+  ~Repository_var (void); // destructor
+  
+  Repository_var &operator= (Repository_ptr);
+  Repository_var &operator= (const Repository_var &);
+  Repository_ptr operator-> (void) const;
+  
+  operator const Repository_ptr &() const;
+  operator Repository_ptr &();
+  // in, inout, out, _retn 
+  Repository_ptr in (void) const;
+  Repository_ptr &inout (void);
+  Repository_ptr &out (void);
+  Repository_ptr _retn (void);
+  Repository_ptr ptr (void) const;
+
+private:
+  Repository_ptr ptr_;
+};
 
-class TAO_Export CORBA_ModuleDef: public virtual CORBA_Container, public virtual CORBA_Contained
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_ModuleDef_ptr _ptr_type;
-    typedef CORBA_ModuleDef_var _var_type;
-  #endif /* __GNUC__ */
 
-    // the static operations
-    static CORBA_ModuleDef_ptr _duplicate (CORBA_ModuleDef_ptr obj);
-    static CORBA_ModuleDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ModuleDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ModuleDef_ptr _nil (void)
-      {
-        return (CORBA::ModuleDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+#endif /* end #if !defined */
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
 
-  protected:
-    CORBA_ModuleDef (void);
-    CORBA_ModuleDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_ModuleDef (void);
-  private:
-    CORBA_ModuleDef (const CORBA_ModuleDef &);
-    void operator= (const CORBA_ModuleDef &);
-  };
+#if !defined (_IR_REPOSITORY___OUT_CH_)
+#define _IR_REPOSITORY___OUT_CH_
+
+class TAO_Export Repository_out
+{
+public:
+  Repository_out (Repository_ptr &);
+  Repository_out (Repository_var &);
+  Repository_out (const Repository_out &);
+  Repository_out &operator= (const Repository_out &);
+  Repository_out &operator= (const Repository_var &);
+  Repository_out &operator= (Repository_ptr);
+  operator Repository_ptr &();
+  Repository_ptr &ptr (void);
+  Repository_ptr operator-> (void);
+  
+private:
+  Repository_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-  struct  CORBA_ModuleDescription
-  {
-    static void _tao_any_destructor (void*);
 
-    TAO_String_Manager name;
-    TAO_String_Manager id;
-    TAO_String_Manager defined_in;
-    TAO_String_Manager version;
-  };
+#if !defined (_IR_REPOSITORY_CH_)
+#define _IR_REPOSITORY_CH_
 
-  class TAO_Export CORBA_ModuleDescription_var
-  {
-  public:
-    CORBA_ModuleDescription_var (void); // default constructor
-    CORBA_ModuleDescription_var (CORBA_ModuleDescription *);
-    CORBA_ModuleDescription_var (const CORBA_ModuleDescription_var &); // copy constructor
-    ~CORBA_ModuleDescription_var (void); // destructor
-
-    CORBA_ModuleDescription_var &operator= (CORBA_ModuleDescription *);
-    CORBA_ModuleDescription_var &operator= (const CORBA_ModuleDescription_var &);
-    CORBA_ModuleDescription *operator-> (void);
-    const CORBA_ModuleDescription *operator-> (void) const;
-
-    operator const CORBA_ModuleDescription &() const;
-    operator CORBA_ModuleDescription &();
-    operator CORBA_ModuleDescription &() const;
-    // in, inout, out, _retn
-    const CORBA_ModuleDescription &in (void) const;
-    CORBA_ModuleDescription &inout (void);
-    CORBA_ModuleDescription *&out (void);
-    CORBA_ModuleDescription *_retn (void);
-    CORBA_ModuleDescription *ptr (void) const;
+class TAO_Export Repository: public virtual Container
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef Repository_ptr _ptr_type;
+  typedef Repository_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  private:
-    CORBA_ModuleDescription *ptr_;
+  // the static operations
+  static Repository_ptr _duplicate (Repository_ptr obj);
+  static Repository_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static Repository_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static Repository_ptr _nil (void)
+    {
+      return (Repository_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::Contained_ptr lookup_id (
+      const char * search_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr get_canonical_typecode (
+      CORBA::TypeCode_ptr tc,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PrimitiveDef_ptr get_primitive (
+      IR::PrimitiveKind kind,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::StringDef_ptr create_string (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::WstringDef_ptr create_wstring (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::SequenceDef_ptr create_sequence (
+      CORBA::ULong bound,
+      IR::IDLType_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ArrayDef_ptr create_array (
+      CORBA::ULong length,
+      IR::IDLType_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FixedDef_ptr create_fixed (
+      CORBA::UShort digits,
+      CORBA::Short scale,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  Repository (void);
+  Repository (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~Repository (void);
+private:
+  Repository (const Repository &);
+  void operator= (const Repository &);
+};
+
+class TAO_IR_Repository_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_Repository_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_Repository_Default_Proxy_Factory (void);
+  
+  virtual Repository_ptr create_proxy (
+      Repository_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_Repository_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_Repository_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_Repository_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  Repository_ptr create_proxy (
+      Repository_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_Repository_Proxy_Factory_Adapter (void);
+  ~TAO_IR_Repository_Proxy_Factory_Adapter (void);
+  TAO_IR_Repository_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_Repository_Proxy_Factory_Adapter &
+    );
+  TAO_IR_Repository_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
-  class TAO_Export CORBA_ModuleDescription_out
+  typedef ACE_Singleton<TAO_IR_Repository_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_Repository_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_Repository_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, Repository)
   {
   public:
-    CORBA_ModuleDescription_out (CORBA_ModuleDescription *&);
-    CORBA_ModuleDescription_out (CORBA_ModuleDescription_var &);
-    CORBA_ModuleDescription_out (const CORBA_ModuleDescription_out &);
-    CORBA_ModuleDescription_out &operator= (const CORBA_ModuleDescription_out &);
-    CORBA_ModuleDescription_out &operator= (CORBA_ModuleDescription *);
-    operator CORBA_ModuleDescription *&();
-    CORBA_ModuleDescription *&ptr (void);
-    CORBA_ModuleDescription *operator-> (void);
+    TAO_IR_Repository_Smart_Proxy_Base (::IR::Repository_ptr proxy);
+    ~TAO_IR_Repository_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::Contained_ptr lookup_id (
+      const char * search_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr get_canonical_typecode (
+      CORBA::TypeCode_ptr tc,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PrimitiveDef_ptr get_primitive (
+      IR::PrimitiveKind kind,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::StringDef_ptr create_string (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::WstringDef_ptr create_wstring (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::SequenceDef_ptr create_sequence (
+      CORBA::ULong bound,
+      IR::IDLType_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ArrayDef_ptr create_array (
+      CORBA::ULong length,
+      IR::IDLType_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FixedDef_ptr create_fixed (
+      CORBA::UShort digits,
+      CORBA::Short scale,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::Repository_var base_proxy_;
+};
 
-  private:
-    CORBA_ModuleDescription *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ModuleDescription_var &);
-  };
 
+#endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Repository;
 
-#if !defined (_CORBA_CONSTANTDEF___VAR_CH_)
-#define _CORBA_CONSTANTDEF___VAR_CH_
 
-  class TAO_Export CORBA_ConstantDef_var
-  {
-  public:
-    CORBA_ConstantDef_var (void); // default constructor
-    CORBA_ConstantDef_var (CORBA_ConstantDef_ptr);
-    CORBA_ConstantDef_var (const CORBA_ConstantDef_var &); // copy constructor
-    ~CORBA_ConstantDef_var (void); // destructor
+#if !defined (_IR_COMPONENTREPOSITORY___PTR_CH_)
+#define _IR_COMPONENTREPOSITORY___PTR_CH_
 
-    CORBA_ConstantDef_var &operator= (CORBA_ConstantDef_ptr);
-    CORBA_ConstantDef_var &operator= (const CORBA_ConstantDef_var &);
-    CORBA_ConstantDef_ptr operator-> (void) const;
+class ComponentRepository;
+typedef ComponentRepository *ComponentRepository_ptr;
 
-    operator const CORBA_ConstantDef_ptr &() const;
-    operator CORBA_ConstantDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ConstantDef_ptr in (void) const;
-    CORBA_ConstantDef_ptr &inout (void);
-    CORBA_ConstantDef_ptr &out (void);
-    CORBA_ConstantDef_ptr _retn (void);
-    CORBA_ConstantDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_ConstantDef_ptr ptr_;
-  };
 
+#if !defined (_IR_COMPONENTREPOSITORY___VAR_CH_)
+#define _IR_COMPONENTREPOSITORY___VAR_CH_
+
+class TAO_Export ComponentRepository_var
+{
+public:
+  ComponentRepository_var (void); // default constructor
+  ComponentRepository_var (ComponentRepository_ptr);
+  ComponentRepository_var (const ComponentRepository_var &); // copy constructor
+  ~ComponentRepository_var (void); // destructor
+  
+  ComponentRepository_var &operator= (ComponentRepository_ptr);
+  ComponentRepository_var &operator= (const ComponentRepository_var &);
+  ComponentRepository_ptr operator-> (void) const;
+  
+  operator const ComponentRepository_ptr &() const;
+  operator ComponentRepository_ptr &();
+  // in, inout, out, _retn 
+  ComponentRepository_ptr in (void) const;
+  ComponentRepository_ptr &inout (void);
+  ComponentRepository_ptr &out (void);
+  ComponentRepository_ptr _retn (void);
+  ComponentRepository_ptr ptr (void) const;
+
+private:
+  ComponentRepository_ptr ptr_;
+};
 
-#endif /* end #if !defined */
 
+#endif /* end #if !defined */
 
-#if !defined (_CORBA_CONSTANTDEF___OUT_CH_)
-#define _CORBA_CONSTANTDEF___OUT_CH_
 
-  class TAO_Export CORBA_ConstantDef_out
-  {
-  public:
-    CORBA_ConstantDef_out (CORBA_ConstantDef_ptr &);
-    CORBA_ConstantDef_out (CORBA_ConstantDef_var &);
-    CORBA_ConstantDef_out (const CORBA_ConstantDef_out &);
-    CORBA_ConstantDef_out &operator= (const CORBA_ConstantDef_out &);
-    CORBA_ConstantDef_out &operator= (const CORBA_ConstantDef_var &);
-    CORBA_ConstantDef_out &operator= (CORBA_ConstantDef_ptr);
-    operator CORBA_ConstantDef_ptr &();
-    CORBA_ConstantDef_ptr &ptr (void);
-    CORBA_ConstantDef_ptr operator-> (void);
+#if !defined (_IR_COMPONENTREPOSITORY___OUT_CH_)
+#define _IR_COMPONENTREPOSITORY___OUT_CH_
 
-  private:
-    CORBA_ConstantDef_ptr &ptr_;
-  };
+class TAO_Export ComponentRepository_out
+{
+public:
+  ComponentRepository_out (ComponentRepository_ptr &);
+  ComponentRepository_out (ComponentRepository_var &);
+  ComponentRepository_out (const ComponentRepository_out &);
+  ComponentRepository_out &operator= (const ComponentRepository_out &);
+  ComponentRepository_out &operator= (const ComponentRepository_var &);
+  ComponentRepository_out &operator= (ComponentRepository_ptr);
+  operator ComponentRepository_ptr &();
+  ComponentRepository_ptr &ptr (void);
+  ComponentRepository_ptr operator-> (void);
+  
+private:
+  ComponentRepository_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONSTANTDEF_CH_)
-#define _CORBA_CONSTANTDEF_CH_
+#if !defined (_IR_COMPONENTREPOSITORY_CH_)
+#define _IR_COMPONENTREPOSITORY_CH_
 
-class TAO_Export CORBA_ConstantDef: public virtual CORBA_Contained
+class TAO_Export ComponentRepository: public virtual Repository
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ComponentRepository_ptr _ptr_type;
+  typedef ComponentRepository_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ComponentRepository_ptr _duplicate (ComponentRepository_ptr obj);
+  static ComponentRepository_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ComponentRepository_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ComponentRepository_ptr _nil (void)
+    {
+      return (ComponentRepository_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::ComponentDef_ptr create_component (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ComponentDef_ptr base_component,
+      const IR::InterfaceDefSeq & supports_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::HomeDef_ptr create_home (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::HomeDef_ptr base_home,
+      IR::ComponentDef_ptr managed_component,
+      IR::ValueDef_ptr primary_key,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  ComponentRepository (void);
+  ComponentRepository (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ComponentRepository (void);
+private:
+  ComponentRepository (const ComponentRepository &);
+  void operator= (const ComponentRepository &);
+};
+
+class TAO_IR_ComponentRepository_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ComponentRepository_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ComponentRepository_Default_Proxy_Factory (void);
+  
+  virtual ComponentRepository_ptr create_proxy (
+      ComponentRepository_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ComponentRepository_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ComponentRepository_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ComponentRepository_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ComponentRepository_ptr create_proxy (
+      ComponentRepository_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ComponentRepository_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ComponentRepository_Proxy_Factory_Adapter (void);
+  TAO_IR_ComponentRepository_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ComponentRepository_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ComponentRepository_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_ComponentRepository_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ComponentRepository_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ComponentRepository_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, ComponentRepository)
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_ConstantDef_ptr _ptr_type;
-    typedef CORBA_ConstantDef_var _var_type;
-  #endif /* __GNUC__ */
+    TAO_IR_ComponentRepository_Smart_Proxy_Base (::IR::ComponentRepository_ptr proxy);
+    ~TAO_IR_ComponentRepository_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::ComponentDef_ptr create_component (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ComponentDef_ptr base_component,
+      const IR::InterfaceDefSeq & supports_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::HomeDef_ptr create_home (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::HomeDef_ptr base_home,
+      IR::ComponentDef_ptr managed_component,
+      IR::ValueDef_ptr primary_key,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::ComponentRepository_var base_proxy_;
+};
 
-    // the static operations
-    static CORBA_ConstantDef_ptr _duplicate (CORBA_ConstantDef_ptr obj);
-    static CORBA_ConstantDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ConstantDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ConstantDef_ptr _nil (void)
-      {
-        return (CORBA::ConstantDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_IDLType_ptr type_def (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentRepository;
 
-    virtual void type_def (
-        CORBA_IDLType_ptr type_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA::Any * value (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_MODULEDEF___PTR_CH_)
+#define _IR_MODULEDEF___PTR_CH_
 
-    virtual void value (
-        const CORBA::Any & value,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+class ModuleDef;
+typedef ModuleDef *ModuleDef_ptr;
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+#endif /* end #if !defined */
 
-  protected:
-    CORBA_ConstantDef (void);
-    CORBA_ConstantDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_ConstantDef (void);
-  private:
-    CORBA_ConstantDef (const CORBA_ConstantDef &);
-    void operator= (const CORBA_ConstantDef &);
-  };
+
+#if !defined (_IR_MODULEDEF___VAR_CH_)
+#define _IR_MODULEDEF___VAR_CH_
+
+class TAO_Export ModuleDef_var
+{
+public:
+  ModuleDef_var (void); // default constructor
+  ModuleDef_var (ModuleDef_ptr);
+  ModuleDef_var (const ModuleDef_var &); // copy constructor
+  ~ModuleDef_var (void); // destructor
+  
+  ModuleDef_var &operator= (ModuleDef_ptr);
+  ModuleDef_var &operator= (const ModuleDef_var &);
+  ModuleDef_ptr operator-> (void) const;
+  
+  operator const ModuleDef_ptr &() const;
+  operator ModuleDef_ptr &();
+  // in, inout, out, _retn 
+  ModuleDef_ptr in (void) const;
+  ModuleDef_ptr &inout (void);
+  ModuleDef_ptr &out (void);
+  ModuleDef_ptr _retn (void);
+  ModuleDef_ptr ptr (void) const;
+
+private:
+  ModuleDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-  struct  CORBA_ConstantDescription
-  {
-    static void _tao_any_destructor (void*);
 
-    TAO_String_Manager name;
-    TAO_String_Manager id;
-    TAO_String_Manager defined_in;
-    TAO_String_Manager version;
-    CORBA::TypeCode_var type;
-    CORBA::Any value;
-  };
+#if !defined (_IR_MODULEDEF___OUT_CH_)
+#define _IR_MODULEDEF___OUT_CH_
 
-  class TAO_Export CORBA_ConstantDescription_var
-  {
-  public:
-    CORBA_ConstantDescription_var (void); // default constructor
-    CORBA_ConstantDescription_var (CORBA_ConstantDescription *);
-    CORBA_ConstantDescription_var (const CORBA_ConstantDescription_var &); // copy constructor
-    ~CORBA_ConstantDescription_var (void); // destructor
-
-    CORBA_ConstantDescription_var &operator= (CORBA_ConstantDescription *);
-    CORBA_ConstantDescription_var &operator= (const CORBA_ConstantDescription_var &);
-    CORBA_ConstantDescription *operator-> (void);
-    const CORBA_ConstantDescription *operator-> (void) const;
-
-    operator const CORBA_ConstantDescription &() const;
-    operator CORBA_ConstantDescription &();
-    operator CORBA_ConstantDescription &() const;
-    // in, inout, out, _retn
-    const CORBA_ConstantDescription &in (void) const;
-    CORBA_ConstantDescription &inout (void);
-    CORBA_ConstantDescription *&out (void);
-    CORBA_ConstantDescription *_retn (void);
-    CORBA_ConstantDescription *ptr (void) const;
+class TAO_Export ModuleDef_out
+{
+public:
+  ModuleDef_out (ModuleDef_ptr &);
+  ModuleDef_out (ModuleDef_var &);
+  ModuleDef_out (const ModuleDef_out &);
+  ModuleDef_out &operator= (const ModuleDef_out &);
+  ModuleDef_out &operator= (const ModuleDef_var &);
+  ModuleDef_out &operator= (ModuleDef_ptr);
+  operator ModuleDef_ptr &();
+  ModuleDef_ptr &ptr (void);
+  ModuleDef_ptr operator-> (void);
+  
+private:
+  ModuleDef_ptr &ptr_;
+};
 
-  private:
-    CORBA_ConstantDescription *ptr_;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_MODULEDEF_CH_)
+#define _IR_MODULEDEF_CH_
+
+class TAO_Export ModuleDef: public virtual Container, public virtual Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ModuleDef_ptr _ptr_type;
+  typedef ModuleDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ModuleDef_ptr _duplicate (ModuleDef_ptr obj);
+  static ModuleDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ModuleDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ModuleDef_ptr _nil (void)
+    {
+      return (ModuleDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  ModuleDef (void);
+  ModuleDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ModuleDef (void);
+private:
+  ModuleDef (const ModuleDef &);
+  void operator= (const ModuleDef &);
+};
+
+class TAO_IR_ModuleDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ModuleDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ModuleDef_Default_Proxy_Factory (void);
+  
+  virtual ModuleDef_ptr create_proxy (
+      ModuleDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ModuleDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ModuleDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ModuleDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ModuleDef_ptr create_proxy (
+      ModuleDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ModuleDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ModuleDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ModuleDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ModuleDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ModuleDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
-  class TAO_Export CORBA_ConstantDescription_out
+  typedef ACE_Singleton<TAO_IR_ModuleDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ModuleDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ModuleDef_Smart_Proxy_Base : public virtual ModuleDef
   {
   public:
-    CORBA_ConstantDescription_out (CORBA_ConstantDescription *&);
-    CORBA_ConstantDescription_out (CORBA_ConstantDescription_var &);
-    CORBA_ConstantDescription_out (const CORBA_ConstantDescription_out &);
-    CORBA_ConstantDescription_out &operator= (const CORBA_ConstantDescription_out &);
-    CORBA_ConstantDescription_out &operator= (CORBA_ConstantDescription *);
-    operator CORBA_ConstantDescription *&();
-    CORBA_ConstantDescription *&ptr (void);
-    CORBA_ConstantDescription *operator-> (void);
+    TAO_IR_ModuleDef_Smart_Proxy_Base (::IR::ModuleDef_ptr proxy);
+    ~TAO_IR_ModuleDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+    private:
+  ::IR::ModuleDef_var base_proxy_;
+};
 
-  private:
-    CORBA_ConstantDescription *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ConstantDescription_var &);
-  };
 
-#if !defined (_CORBA_TYPEDEFDEF___VAR_CH_)
-#define _CORBA_TYPEDEFDEF___VAR_CH_
+#endif /* end #if !defined */
 
-  class TAO_Export CORBA_TypedefDef_var
-  {
-  public:
-    CORBA_TypedefDef_var (void); // default constructor
-    CORBA_TypedefDef_var (CORBA_TypedefDef_ptr);
-    CORBA_TypedefDef_var (const CORBA_TypedefDef_var &); // copy constructor
-    ~CORBA_TypedefDef_var (void); // destructor
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDef;
+
+struct ModuleDescription;
+class ModuleDescription_var;
+
+struct TAO_Export ModuleDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ModuleDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+};
+
+class TAO_Export ModuleDescription_var
+{
+public:
+  ModuleDescription_var (void); // default constructor
+  ModuleDescription_var (ModuleDescription *);
+  ModuleDescription_var (const ModuleDescription_var &); // copy constructor
+  ~ModuleDescription_var (void); // destructor
+  
+  ModuleDescription_var &operator= (ModuleDescription *);
+  ModuleDescription_var &operator= (const ModuleDescription_var &);
+  ModuleDescription *operator-> (void);
+  const ModuleDescription *operator-> (void) const;
+  
+  operator const ModuleDescription &() const;
+  operator ModuleDescription &();
+  operator ModuleDescription &() const;
+  operator ModuleDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const ModuleDescription &in (void) const;
+  ModuleDescription &inout (void);
+  ModuleDescription *&out (void);
+  ModuleDescription *_retn (void);
+  ModuleDescription *ptr (void) const;
+
+private:
+  ModuleDescription *ptr_;
+};
+
+class TAO_Export ModuleDescription_out
+{
+public:
+  ModuleDescription_out (ModuleDescription *&);
+  ModuleDescription_out (ModuleDescription_var &);
+  ModuleDescription_out (const ModuleDescription_out &);
+  ModuleDescription_out &operator= (const ModuleDescription_out &);
+  ModuleDescription_out &operator= (ModuleDescription *);
+  operator ModuleDescription *&();
+  ModuleDescription *&ptr (void);
+  ModuleDescription *operator-> (void);
+  
+private:
+  ModuleDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ModuleDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDescription;
+
+
+#if !defined (_IR_CONSTANTDEF___PTR_CH_)
+#define _IR_CONSTANTDEF___PTR_CH_
+
+class ConstantDef;
+typedef ConstantDef *ConstantDef_ptr;
 
-    CORBA_TypedefDef_var &operator= (CORBA_TypedefDef_ptr);
-    CORBA_TypedefDef_var &operator= (const CORBA_TypedefDef_var &);
-    CORBA_TypedefDef_ptr operator-> (void) const;
+#endif /* end #if !defined */
 
-    operator const CORBA_TypedefDef_ptr &() const;
-    operator CORBA_TypedefDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_TypedefDef_ptr in (void) const;
-    CORBA_TypedefDef_ptr &inout (void);
-    CORBA_TypedefDef_ptr &out (void);
-    CORBA_TypedefDef_ptr _retn (void);
-    CORBA_TypedefDef_ptr ptr (void) const;
 
-  private:
-    CORBA_TypedefDef_ptr ptr_;
-  };
+#if !defined (_IR_CONSTANTDEF___VAR_CH_)
+#define _IR_CONSTANTDEF___VAR_CH_
+
+class TAO_Export ConstantDef_var
+{
+public:
+  ConstantDef_var (void); // default constructor
+  ConstantDef_var (ConstantDef_ptr);
+  ConstantDef_var (const ConstantDef_var &); // copy constructor
+  ~ConstantDef_var (void); // destructor
+  
+  ConstantDef_var &operator= (ConstantDef_ptr);
+  ConstantDef_var &operator= (const ConstantDef_var &);
+  ConstantDef_ptr operator-> (void) const;
+  
+  operator const ConstantDef_ptr &() const;
+  operator ConstantDef_ptr &();
+  // in, inout, out, _retn 
+  ConstantDef_ptr in (void) const;
+  ConstantDef_ptr &inout (void);
+  ConstantDef_ptr &out (void);
+  ConstantDef_ptr _retn (void);
+  ConstantDef_ptr ptr (void) const;
+
+private:
+  ConstantDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_TYPEDEFDEF___OUT_CH_)
-#define _CORBA_TYPEDEFDEF___OUT_CH_
+#if !defined (_IR_CONSTANTDEF___OUT_CH_)
+#define _IR_CONSTANTDEF___OUT_CH_
+
+class TAO_Export ConstantDef_out
+{
+public:
+  ConstantDef_out (ConstantDef_ptr &);
+  ConstantDef_out (ConstantDef_var &);
+  ConstantDef_out (const ConstantDef_out &);
+  ConstantDef_out &operator= (const ConstantDef_out &);
+  ConstantDef_out &operator= (const ConstantDef_var &);
+  ConstantDef_out &operator= (ConstantDef_ptr);
+  operator ConstantDef_ptr &();
+  ConstantDef_ptr &ptr (void);
+  ConstantDef_ptr operator-> (void);
+  
+private:
+  ConstantDef_ptr &ptr_;
+};
+
 
-  class TAO_Export CORBA_TypedefDef_out
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONSTANTDEF_CH_)
+#define _IR_CONSTANTDEF_CH_
+
+class TAO_Export ConstantDef: public virtual Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ConstantDef_ptr _ptr_type;
+  typedef ConstantDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ConstantDef_ptr _duplicate (ConstantDef_ptr obj);
+  static ConstantDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ConstantDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ConstantDef_ptr _nil (void)
+    {
+      return (ConstantDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      IR::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Any * value (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void value (
+      const CORBA::Any & value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  ConstantDef (void);
+  ConstantDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ConstantDef (void);
+private:
+  ConstantDef (const ConstantDef &);
+  void operator= (const ConstantDef &);
+};
+
+class TAO_IR_ConstantDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ConstantDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ConstantDef_Default_Proxy_Factory (void);
+  
+  virtual ConstantDef_ptr create_proxy (
+      ConstantDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ConstantDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ConstantDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ConstantDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ConstantDef_ptr create_proxy (
+      ConstantDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ConstantDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ConstantDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ConstantDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ConstantDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ConstantDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_ConstantDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ConstantDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ConstantDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, ConstantDef)
   {
   public:
-    CORBA_TypedefDef_out (CORBA_TypedefDef_ptr &);
-    CORBA_TypedefDef_out (CORBA_TypedefDef_var &);
-    CORBA_TypedefDef_out (const CORBA_TypedefDef_out &);
-    CORBA_TypedefDef_out &operator= (const CORBA_TypedefDef_out &);
-    CORBA_TypedefDef_out &operator= (const CORBA_TypedefDef_var &);
-    CORBA_TypedefDef_out &operator= (CORBA_TypedefDef_ptr);
-    operator CORBA_TypedefDef_ptr &();
-    CORBA_TypedefDef_ptr &ptr (void);
-    CORBA_TypedefDef_ptr operator-> (void);
+    TAO_IR_ConstantDef_Smart_Proxy_Base (::IR::ConstantDef_ptr proxy);
+    ~TAO_IR_ConstantDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      IR::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Any * value (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void value (
+      const CORBA::Any & value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::ConstantDef_var base_proxy_;
+};
 
-  private:
-    CORBA_TypedefDef_ptr &ptr_;
-  };
 
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDef;
+
+struct ConstantDescription;
+class ConstantDescription_var;
+
+struct TAO_Export ConstantDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ConstantDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+  CORBA::Any value;
+};
+
+class TAO_Export ConstantDescription_var
+{
+public:
+  ConstantDescription_var (void); // default constructor
+  ConstantDescription_var (ConstantDescription *);
+  ConstantDescription_var (const ConstantDescription_var &); // copy constructor
+  ~ConstantDescription_var (void); // destructor
+  
+  ConstantDescription_var &operator= (ConstantDescription *);
+  ConstantDescription_var &operator= (const ConstantDescription_var &);
+  ConstantDescription *operator-> (void);
+  const ConstantDescription *operator-> (void) const;
+  
+  operator const ConstantDescription &() const;
+  operator ConstantDescription &();
+  operator ConstantDescription &() const;
+  operator ConstantDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const ConstantDescription &in (void) const;
+  ConstantDescription &inout (void);
+  ConstantDescription *&out (void);
+  ConstantDescription *_retn (void);
+  ConstantDescription *ptr (void) const;
+
+private:
+  ConstantDescription *ptr_;
+};
+
+class TAO_Export ConstantDescription_out
+{
+public:
+  ConstantDescription_out (ConstantDescription *&);
+  ConstantDescription_out (ConstantDescription_var &);
+  ConstantDescription_out (const ConstantDescription_out &);
+  ConstantDescription_out &operator= (const ConstantDescription_out &);
+  ConstantDescription_out &operator= (ConstantDescription *);
+  operator ConstantDescription *&();
+  ConstantDescription *&ptr (void);
+  ConstantDescription *operator-> (void);
+  
+private:
+  ConstantDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ConstantDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDescription;
+
+
+#if !defined (_IR_TYPEDEFDEF___PTR_CH_)
+#define _IR_TYPEDEFDEF___PTR_CH_
+
+class TypedefDef;
+typedef TypedefDef *TypedefDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_TYPEDEFDEF_CH_)
-#define _CORBA_TYPEDEFDEF_CH_
+#if !defined (_IR_TYPEDEFDEF___VAR_CH_)
+#define _IR_TYPEDEFDEF___VAR_CH_
+
+class TAO_Export TypedefDef_var
+{
+public:
+  TypedefDef_var (void); // default constructor
+  TypedefDef_var (TypedefDef_ptr);
+  TypedefDef_var (const TypedefDef_var &); // copy constructor
+  ~TypedefDef_var (void); // destructor
+  
+  TypedefDef_var &operator= (TypedefDef_ptr);
+  TypedefDef_var &operator= (const TypedefDef_var &);
+  TypedefDef_ptr operator-> (void) const;
+  
+  operator const TypedefDef_ptr &() const;
+  operator TypedefDef_ptr &();
+  // in, inout, out, _retn 
+  TypedefDef_ptr in (void) const;
+  TypedefDef_ptr &inout (void);
+  TypedefDef_ptr &out (void);
+  TypedefDef_ptr _retn (void);
+  TypedefDef_ptr ptr (void) const;
+
+private:
+  TypedefDef_ptr ptr_;
+};
 
-class TAO_Export CORBA_TypedefDef: public virtual CORBA_Contained, public virtual CORBA_IDLType
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_TypedefDef_ptr _ptr_type;
-    typedef CORBA_TypedefDef_var _var_type;
-  #endif /* __GNUC__ */
 
-    // the static operations
-    static CORBA_TypedefDef_ptr _duplicate (CORBA_TypedefDef_ptr obj);
-    static CORBA_TypedefDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_TypedefDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_TypedefDef_ptr _nil (void)
-      {
-        return (CORBA::TypedefDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+#endif /* end #if !defined */
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
 
-  protected:
-    CORBA_TypedefDef (void);
-    CORBA_TypedefDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_TypedefDef (void);
-  private:
-    CORBA_TypedefDef (const CORBA_TypedefDef &);
-    void operator= (const CORBA_TypedefDef &);
-  };
+#if !defined (_IR_TYPEDEFDEF___OUT_CH_)
+#define _IR_TYPEDEFDEF___OUT_CH_
+
+class TAO_Export TypedefDef_out
+{
+public:
+  TypedefDef_out (TypedefDef_ptr &);
+  TypedefDef_out (TypedefDef_var &);
+  TypedefDef_out (const TypedefDef_out &);
+  TypedefDef_out &operator= (const TypedefDef_out &);
+  TypedefDef_out &operator= (const TypedefDef_var &);
+  TypedefDef_out &operator= (TypedefDef_ptr);
+  operator TypedefDef_ptr &();
+  TypedefDef_ptr &ptr (void);
+  TypedefDef_ptr operator-> (void);
+  
+private:
+  TypedefDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-  struct  CORBA_TypeDescription
-  {
-    static void _tao_any_destructor (void*);
 
-    TAO_String_Manager name;
-    TAO_String_Manager id;
-    TAO_String_Manager defined_in;
-    TAO_String_Manager version;
-    CORBA::TypeCode_var type;
-  };
+#if !defined (_IR_TYPEDEFDEF_CH_)
+#define _IR_TYPEDEFDEF_CH_
 
-  class TAO_Export CORBA_TypeDescription_var
-  {
-  public:
-    CORBA_TypeDescription_var (void); // default constructor
-    CORBA_TypeDescription_var (CORBA_TypeDescription *);
-    CORBA_TypeDescription_var (const CORBA_TypeDescription_var &); // copy constructor
-    ~CORBA_TypeDescription_var (void); // destructor
-
-    CORBA_TypeDescription_var &operator= (CORBA_TypeDescription *);
-    CORBA_TypeDescription_var &operator= (const CORBA_TypeDescription_var &);
-    CORBA_TypeDescription *operator-> (void);
-    const CORBA_TypeDescription *operator-> (void) const;
-
-    operator const CORBA_TypeDescription &() const;
-    operator CORBA_TypeDescription &();
-    operator CORBA_TypeDescription &() const;
-    // in, inout, out, _retn
-    const CORBA_TypeDescription &in (void) const;
-    CORBA_TypeDescription &inout (void);
-    CORBA_TypeDescription *&out (void);
-    CORBA_TypeDescription *_retn (void);
-    CORBA_TypeDescription *ptr (void) const;
+class TAO_Export TypedefDef: public virtual Contained, public virtual IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef TypedefDef_ptr _ptr_type;
+  typedef TypedefDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  private:
-    CORBA_TypeDescription *ptr_;
+  // the static operations
+  static TypedefDef_ptr _duplicate (TypedefDef_ptr obj);
+  static TypedefDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static TypedefDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static TypedefDef_ptr _nil (void)
+    {
+      return (TypedefDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  TypedefDef (void);
+  TypedefDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~TypedefDef (void);
+private:
+  TypedefDef (const TypedefDef &);
+  void operator= (const TypedefDef &);
+};
+
+class TAO_IR_TypedefDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_TypedefDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_TypedefDef_Default_Proxy_Factory (void);
+  
+  virtual TypedefDef_ptr create_proxy (
+      TypedefDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_TypedefDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_TypedefDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_TypedefDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  TypedefDef_ptr create_proxy (
+      TypedefDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_TypedefDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_TypedefDef_Proxy_Factory_Adapter (void);
+  TAO_IR_TypedefDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_TypedefDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_TypedefDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
-  class TAO_Export CORBA_TypeDescription_out
+  typedef ACE_Singleton<TAO_IR_TypedefDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_TypedefDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_TypedefDef_Smart_Proxy_Base : public virtual TypedefDef
   {
   public:
-    CORBA_TypeDescription_out (CORBA_TypeDescription *&);
-    CORBA_TypeDescription_out (CORBA_TypeDescription_var &);
-    CORBA_TypeDescription_out (const CORBA_TypeDescription_out &);
-    CORBA_TypeDescription_out &operator= (const CORBA_TypeDescription_out &);
-    CORBA_TypeDescription_out &operator= (CORBA_TypeDescription *);
-    operator CORBA_TypeDescription *&();
-    CORBA_TypeDescription *&ptr (void);
-    CORBA_TypeDescription *operator-> (void);
+    TAO_IR_TypedefDef_Smart_Proxy_Base (::IR::TypedefDef_ptr proxy);
+    ~TAO_IR_TypedefDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+    private:
+  ::IR::TypedefDef_var base_proxy_;
+};
 
-  private:
-    CORBA_TypeDescription *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_TypeDescription_var &);
-  };
 
-#if !defined (_CORBA_STRUCTDEF___VAR_CH_)
-#define _CORBA_STRUCTDEF___VAR_CH_
+#endif /* end #if !defined */
 
-  class TAO_Export CORBA_StructDef_var
-  {
-  public:
-    CORBA_StructDef_var (void); // default constructor
-    CORBA_StructDef_var (CORBA_StructDef_ptr);
-    CORBA_StructDef_var (const CORBA_StructDef_var &); // copy constructor
-    ~CORBA_StructDef_var (void); // destructor
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypedefDef;
+
+struct TypeDescription;
+class TypeDescription_var;
+
+struct TAO_Export TypeDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef TypeDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+};
+
+class TAO_Export TypeDescription_var
+{
+public:
+  TypeDescription_var (void); // default constructor
+  TypeDescription_var (TypeDescription *);
+  TypeDescription_var (const TypeDescription_var &); // copy constructor
+  ~TypeDescription_var (void); // destructor
+  
+  TypeDescription_var &operator= (TypeDescription *);
+  TypeDescription_var &operator= (const TypeDescription_var &);
+  TypeDescription *operator-> (void);
+  const TypeDescription *operator-> (void) const;
+  
+  operator const TypeDescription &() const;
+  operator TypeDescription &();
+  operator TypeDescription &() const;
+  operator TypeDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const TypeDescription &in (void) const;
+  TypeDescription &inout (void);
+  TypeDescription *&out (void);
+  TypeDescription *_retn (void);
+  TypeDescription *ptr (void) const;
+
+private:
+  TypeDescription *ptr_;
+};
+
+class TAO_Export TypeDescription_out
+{
+public:
+  TypeDescription_out (TypeDescription *&);
+  TypeDescription_out (TypeDescription_var &);
+  TypeDescription_out (const TypeDescription_out &);
+  TypeDescription_out &operator= (const TypeDescription_out &);
+  TypeDescription_out &operator= (TypeDescription *);
+  operator TypeDescription *&();
+  TypeDescription *&ptr (void);
+  TypeDescription *operator-> (void);
+  
+private:
+  TypeDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const TypeDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypeDescription;
+
+
+#if !defined (_IR_STRUCTDEF___PTR_CH_)
+#define _IR_STRUCTDEF___PTR_CH_
+
+class StructDef;
+typedef StructDef *StructDef_ptr;
 
-    CORBA_StructDef_var &operator= (CORBA_StructDef_ptr);
-    CORBA_StructDef_var &operator= (const CORBA_StructDef_var &);
-    CORBA_StructDef_ptr operator-> (void) const;
+#endif /* end #if !defined */
 
-    operator const CORBA_StructDef_ptr &() const;
-    operator CORBA_StructDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_StructDef_ptr in (void) const;
-    CORBA_StructDef_ptr &inout (void);
-    CORBA_StructDef_ptr &out (void);
-    CORBA_StructDef_ptr _retn (void);
-    CORBA_StructDef_ptr ptr (void) const;
 
-  private:
-    CORBA_StructDef_ptr ptr_;
-  };
+#if !defined (_IR_STRUCTDEF___VAR_CH_)
+#define _IR_STRUCTDEF___VAR_CH_
+
+class TAO_Export StructDef_var
+{
+public:
+  StructDef_var (void); // default constructor
+  StructDef_var (StructDef_ptr);
+  StructDef_var (const StructDef_var &); // copy constructor
+  ~StructDef_var (void); // destructor
+  
+  StructDef_var &operator= (StructDef_ptr);
+  StructDef_var &operator= (const StructDef_var &);
+  StructDef_ptr operator-> (void) const;
+  
+  operator const StructDef_ptr &() const;
+  operator StructDef_ptr &();
+  // in, inout, out, _retn 
+  StructDef_ptr in (void) const;
+  StructDef_ptr &inout (void);
+  StructDef_ptr &out (void);
+  StructDef_ptr _retn (void);
+  StructDef_ptr ptr (void) const;
+
+private:
+  StructDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRUCTDEF___OUT_CH_)
-#define _CORBA_STRUCTDEF___OUT_CH_
-
-  class TAO_Export CORBA_StructDef_out
-  {
-  public:
-    CORBA_StructDef_out (CORBA_StructDef_ptr &);
-    CORBA_StructDef_out (CORBA_StructDef_var &);
-    CORBA_StructDef_out (const CORBA_StructDef_out &);
-    CORBA_StructDef_out &operator= (const CORBA_StructDef_out &);
-    CORBA_StructDef_out &operator= (const CORBA_StructDef_var &);
-    CORBA_StructDef_out &operator= (CORBA_StructDef_ptr);
-    operator CORBA_StructDef_ptr &();
-    CORBA_StructDef_ptr &ptr (void);
-    CORBA_StructDef_ptr operator-> (void);
+#if !defined (_IR_STRUCTDEF___OUT_CH_)
+#define _IR_STRUCTDEF___OUT_CH_
 
-  private:
-    CORBA_StructDef_ptr &ptr_;
-  };
+class TAO_Export StructDef_out
+{
+public:
+  StructDef_out (StructDef_ptr &);
+  StructDef_out (StructDef_var &);
+  StructDef_out (const StructDef_out &);
+  StructDef_out &operator= (const StructDef_out &);
+  StructDef_out &operator= (const StructDef_var &);
+  StructDef_out &operator= (StructDef_ptr);
+  operator StructDef_ptr &();
+  StructDef_ptr &ptr (void);
+  StructDef_ptr operator-> (void);
+  
+private:
+  StructDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRUCTDEF_CH_)
-#define _CORBA_STRUCTDEF_CH_
+#if !defined (_IR_STRUCTDEF_CH_)
+#define _IR_STRUCTDEF_CH_
 
-class TAO_Export CORBA_StructDef: public virtual CORBA_TypedefDef, public virtual CORBA_Container
+class TAO_Export StructDef: public virtual TypedefDef, public virtual Container
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef StructDef_ptr _ptr_type;
+  typedef StructDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static StructDef_ptr _duplicate (StructDef_ptr obj);
+  static StructDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static StructDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static StructDef_ptr _nil (void)
+    {
+      return (StructDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::StructMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const IR::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  StructDef (void);
+  StructDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~StructDef (void);
+private:
+  StructDef (const StructDef &);
+  void operator= (const StructDef &);
+};
+
+class TAO_IR_StructDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_StructDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_StructDef_Default_Proxy_Factory (void);
+  
+  virtual StructDef_ptr create_proxy (
+      StructDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_StructDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_StructDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_StructDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  StructDef_ptr create_proxy (
+      StructDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_StructDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_StructDef_Proxy_Factory_Adapter (void);
+  TAO_IR_StructDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_StructDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_StructDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_StructDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_StructDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_StructDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, StructDef)
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_StructDef_ptr _ptr_type;
-    typedef CORBA_StructDef_var _var_type;
-  #endif /* __GNUC__ */
+    TAO_IR_StructDef_Smart_Proxy_Base (::IR::StructDef_ptr proxy);
+    ~TAO_IR_StructDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::StructMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const IR::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::StructDef_var base_proxy_;
+};
 
-    // the static operations
-    static CORBA_StructDef_ptr _duplicate (CORBA_StructDef_ptr obj);
-    static CORBA_StructDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_StructDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_StructDef_ptr _nil (void)
-      {
-        return (CORBA::StructDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA_StructMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual void members (
-        const CORBA_StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructDef;
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
 
-  protected:
-    CORBA_StructDef (void);
-    CORBA_StructDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_StructDef (void);
-  private:
-    CORBA_StructDef (const CORBA_StructDef &);
-    void operator= (const CORBA_StructDef &);
-  };
+#if !defined (_IR_UNIONDEF___PTR_CH_)
+#define _IR_UNIONDEF___PTR_CH_
 
+class UnionDef;
+typedef UnionDef *UnionDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_UNIONDEF___VAR_CH_)
-#define _CORBA_UNIONDEF___VAR_CH_
+#if !defined (_IR_UNIONDEF___VAR_CH_)
+#define _IR_UNIONDEF___VAR_CH_
+
+class TAO_Export UnionDef_var
+{
+public:
+  UnionDef_var (void); // default constructor
+  UnionDef_var (UnionDef_ptr);
+  UnionDef_var (const UnionDef_var &); // copy constructor
+  ~UnionDef_var (void); // destructor
+  
+  UnionDef_var &operator= (UnionDef_ptr);
+  UnionDef_var &operator= (const UnionDef_var &);
+  UnionDef_ptr operator-> (void) const;
+  
+  operator const UnionDef_ptr &() const;
+  operator UnionDef_ptr &();
+  // in, inout, out, _retn 
+  UnionDef_ptr in (void) const;
+  UnionDef_ptr &inout (void);
+  UnionDef_ptr &out (void);
+  UnionDef_ptr _retn (void);
+  UnionDef_ptr ptr (void) const;
+
+private:
+  UnionDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_UnionDef_var
-  {
-  public:
-    CORBA_UnionDef_var (void); // default constructor
-    CORBA_UnionDef_var (CORBA_UnionDef_ptr);
-    CORBA_UnionDef_var (const CORBA_UnionDef_var &); // copy constructor
-    ~CORBA_UnionDef_var (void); // destructor
 
-    CORBA_UnionDef_var &operator= (CORBA_UnionDef_ptr);
-    CORBA_UnionDef_var &operator= (const CORBA_UnionDef_var &);
-    CORBA_UnionDef_ptr operator-> (void) const;
+#endif /* end #if !defined */
 
-    operator const CORBA_UnionDef_ptr &() const;
-    operator CORBA_UnionDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_UnionDef_ptr in (void) const;
-    CORBA_UnionDef_ptr &inout (void);
-    CORBA_UnionDef_ptr &out (void);
-    CORBA_UnionDef_ptr _retn (void);
-    CORBA_UnionDef_ptr ptr (void) const;
 
-  private:
-    CORBA_UnionDef_ptr ptr_;
-  };
+#if !defined (_IR_UNIONDEF___OUT_CH_)
+#define _IR_UNIONDEF___OUT_CH_
+
+class TAO_Export UnionDef_out
+{
+public:
+  UnionDef_out (UnionDef_ptr &);
+  UnionDef_out (UnionDef_var &);
+  UnionDef_out (const UnionDef_out &);
+  UnionDef_out &operator= (const UnionDef_out &);
+  UnionDef_out &operator= (const UnionDef_var &);
+  UnionDef_out &operator= (UnionDef_ptr);
+  operator UnionDef_ptr &();
+  UnionDef_ptr &ptr (void);
+  UnionDef_ptr operator-> (void);
+  
+private:
+  UnionDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_UNIONDEF___OUT_CH_)
-#define _CORBA_UNIONDEF___OUT_CH_
+#if !defined (_IR_UNIONDEF_CH_)
+#define _IR_UNIONDEF_CH_
 
-  class TAO_Export CORBA_UnionDef_out
-  {
-  public:
-    CORBA_UnionDef_out (CORBA_UnionDef_ptr &);
-    CORBA_UnionDef_out (CORBA_UnionDef_var &);
-    CORBA_UnionDef_out (const CORBA_UnionDef_out &);
-    CORBA_UnionDef_out &operator= (const CORBA_UnionDef_out &);
-    CORBA_UnionDef_out &operator= (const CORBA_UnionDef_var &);
-    CORBA_UnionDef_out &operator= (CORBA_UnionDef_ptr);
-    operator CORBA_UnionDef_ptr &();
-    CORBA_UnionDef_ptr &ptr (void);
-    CORBA_UnionDef_ptr operator-> (void);
+class TAO_Export UnionDef: public virtual TypedefDef, public virtual Container
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UnionDef_ptr _ptr_type;
+  typedef UnionDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  private:
-    CORBA_UnionDef_ptr &ptr_;
+  // the static operations
+  static UnionDef_ptr _duplicate (UnionDef_ptr obj);
+  static UnionDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static UnionDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static UnionDef_ptr _nil (void)
+    {
+      return (UnionDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr discriminator_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr discriminator_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void discriminator_type_def (
+      IR::IDLType_ptr discriminator_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::UnionMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const IR::UnionMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  UnionDef (void);
+  UnionDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~UnionDef (void);
+private:
+  UnionDef (const UnionDef &);
+  void operator= (const UnionDef &);
+};
+
+class TAO_IR_UnionDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_UnionDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_UnionDef_Default_Proxy_Factory (void);
+  
+  virtual UnionDef_ptr create_proxy (
+      UnionDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_UnionDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_UnionDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_UnionDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  UnionDef_ptr create_proxy (
+      UnionDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_UnionDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_UnionDef_Proxy_Factory_Adapter (void);
+  TAO_IR_UnionDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_UnionDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_UnionDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
+  typedef ACE_Singleton<TAO_IR_UnionDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_UnionDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_UnionDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, UnionDef)
+  {
+  public:
+    TAO_IR_UnionDef_Smart_Proxy_Base (::IR::UnionDef_ptr proxy);
+    ~TAO_IR_UnionDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::TypeCode_ptr discriminator_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr discriminator_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void discriminator_type_def (
+      IR::IDLType_ptr discriminator_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::UnionMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const IR::UnionMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::UnionDef_var base_proxy_;
+};
+
 
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionDef;
 
-#if !defined (_CORBA_UNIONDEF_CH_)
-#define _CORBA_UNIONDEF_CH_
 
-class TAO_Export CORBA_UnionDef: public virtual CORBA_TypedefDef, public virtual CORBA_Container
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_UnionDef_ptr _ptr_type;
-    typedef CORBA_UnionDef_var _var_type;
-  #endif /* __GNUC__ */
+#if !defined (_IR_ENUMDEF___PTR_CH_)
+#define _IR_ENUMDEF___PTR_CH_
 
-    // the static operations
-    static CORBA_UnionDef_ptr _duplicate (CORBA_UnionDef_ptr obj);
-    static CORBA_UnionDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_UnionDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_UnionDef_ptr _nil (void)
-      {
-        return (CORBA::UnionDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+class EnumDef;
+typedef EnumDef *EnumDef_ptr;
 
-    virtual CORBA::TypeCode_ptr discriminator_type (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_IDLType_ptr discriminator_type_def (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual void discriminator_type_def (
-        CORBA_IDLType_ptr discriminator_type_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_ENUMDEF___VAR_CH_)
+#define _IR_ENUMDEF___VAR_CH_
+
+class TAO_Export EnumDef_var
+{
+public:
+  EnumDef_var (void); // default constructor
+  EnumDef_var (EnumDef_ptr);
+  EnumDef_var (const EnumDef_var &); // copy constructor
+  ~EnumDef_var (void); // destructor
+  
+  EnumDef_var &operator= (EnumDef_ptr);
+  EnumDef_var &operator= (const EnumDef_var &);
+  EnumDef_ptr operator-> (void) const;
+  
+  operator const EnumDef_ptr &() const;
+  operator EnumDef_ptr &();
+  // in, inout, out, _retn 
+  EnumDef_ptr in (void) const;
+  EnumDef_ptr &inout (void);
+  EnumDef_ptr &out (void);
+  EnumDef_ptr _retn (void);
+  EnumDef_ptr ptr (void) const;
+
+private:
+  EnumDef_ptr ptr_;
+};
 
-    virtual CORBA_UnionMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual void members (
-        const CORBA_UnionMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
 
-  protected:
-    CORBA_UnionDef (void);
-    CORBA_UnionDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_UnionDef (void);
-  private:
-    CORBA_UnionDef (const CORBA_UnionDef &);
-    void operator= (const CORBA_UnionDef &);
-  };
+#if !defined (_IR_ENUMDEF___OUT_CH_)
+#define _IR_ENUMDEF___OUT_CH_
+
+class TAO_Export EnumDef_out
+{
+public:
+  EnumDef_out (EnumDef_ptr &);
+  EnumDef_out (EnumDef_var &);
+  EnumDef_out (const EnumDef_out &);
+  EnumDef_out &operator= (const EnumDef_out &);
+  EnumDef_out &operator= (const EnumDef_var &);
+  EnumDef_out &operator= (EnumDef_ptr);
+  operator EnumDef_ptr &();
+  EnumDef_ptr &ptr (void);
+  EnumDef_ptr operator-> (void);
+  
+private:
+  EnumDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_ENUMDEF___VAR_CH_)
-#define _CORBA_ENUMDEF___VAR_CH_
 
-  class TAO_Export CORBA_EnumDef_var
+#if !defined (_IR_ENUMDEF_CH_)
+#define _IR_ENUMDEF_CH_
+
+class TAO_Export EnumDef: public virtual TypedefDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef EnumDef_ptr _ptr_type;
+  typedef EnumDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static EnumDef_ptr _duplicate (EnumDef_ptr obj);
+  static EnumDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static EnumDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static EnumDef_ptr _nil (void)
+    {
+      return (EnumDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::EnumMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const IR::EnumMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  EnumDef (void);
+  EnumDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~EnumDef (void);
+private:
+  EnumDef (const EnumDef &);
+  void operator= (const EnumDef &);
+};
+
+class TAO_IR_EnumDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_EnumDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_EnumDef_Default_Proxy_Factory (void);
+  
+  virtual EnumDef_ptr create_proxy (
+      EnumDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_EnumDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_EnumDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_EnumDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  EnumDef_ptr create_proxy (
+      EnumDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_EnumDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_EnumDef_Proxy_Factory_Adapter (void);
+  TAO_IR_EnumDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_EnumDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_EnumDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_EnumDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_EnumDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_EnumDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, EnumDef)
   {
   public:
-    CORBA_EnumDef_var (void); // default constructor
-    CORBA_EnumDef_var (CORBA_EnumDef_ptr);
-    CORBA_EnumDef_var (const CORBA_EnumDef_var &); // copy constructor
-    ~CORBA_EnumDef_var (void); // destructor
+    TAO_IR_EnumDef_Smart_Proxy_Base (::IR::EnumDef_ptr proxy);
+    ~TAO_IR_EnumDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::EnumMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const IR::EnumMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::EnumDef_var base_proxy_;
+};
 
-    CORBA_EnumDef_var &operator= (CORBA_EnumDef_ptr);
-    CORBA_EnumDef_var &operator= (const CORBA_EnumDef_var &);
-    CORBA_EnumDef_ptr operator-> (void) const;
 
-    operator const CORBA_EnumDef_ptr &() const;
-    operator CORBA_EnumDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_EnumDef_ptr in (void) const;
-    CORBA_EnumDef_ptr &inout (void);
-    CORBA_EnumDef_ptr &out (void);
-    CORBA_EnumDef_ptr _retn (void);
-    CORBA_EnumDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_EnumDef_ptr ptr_;
-  };
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumDef;
 
 
+#if !defined (_IR_ALIASDEF___PTR_CH_)
+#define _IR_ALIASDEF___PTR_CH_
+
+class AliasDef;
+typedef AliasDef *AliasDef_ptr;
+
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ENUMDEF___OUT_CH_)
-#define _CORBA_ENUMDEF___OUT_CH_
+#if !defined (_IR_ALIASDEF___VAR_CH_)
+#define _IR_ALIASDEF___VAR_CH_
+
+class TAO_Export AliasDef_var
+{
+public:
+  AliasDef_var (void); // default constructor
+  AliasDef_var (AliasDef_ptr);
+  AliasDef_var (const AliasDef_var &); // copy constructor
+  ~AliasDef_var (void); // destructor
+  
+  AliasDef_var &operator= (AliasDef_ptr);
+  AliasDef_var &operator= (const AliasDef_var &);
+  AliasDef_ptr operator-> (void) const;
+  
+  operator const AliasDef_ptr &() const;
+  operator AliasDef_ptr &();
+  // in, inout, out, _retn 
+  AliasDef_ptr in (void) const;
+  AliasDef_ptr &inout (void);
+  AliasDef_ptr &out (void);
+  AliasDef_ptr _retn (void);
+  AliasDef_ptr ptr (void) const;
+
+private:
+  AliasDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_EnumDef_out
-  {
-  public:
-    CORBA_EnumDef_out (CORBA_EnumDef_ptr &);
-    CORBA_EnumDef_out (CORBA_EnumDef_var &);
-    CORBA_EnumDef_out (const CORBA_EnumDef_out &);
-    CORBA_EnumDef_out &operator= (const CORBA_EnumDef_out &);
-    CORBA_EnumDef_out &operator= (const CORBA_EnumDef_var &);
-    CORBA_EnumDef_out &operator= (CORBA_EnumDef_ptr);
-    operator CORBA_EnumDef_ptr &();
-    CORBA_EnumDef_ptr &ptr (void);
-    CORBA_EnumDef_ptr operator-> (void);
 
-  private:
-    CORBA_EnumDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_ALIASDEF___OUT_CH_)
+#define _IR_ALIASDEF___OUT_CH_
+
+class TAO_Export AliasDef_out
+{
+public:
+  AliasDef_out (AliasDef_ptr &);
+  AliasDef_out (AliasDef_var &);
+  AliasDef_out (const AliasDef_out &);
+  AliasDef_out &operator= (const AliasDef_out &);
+  AliasDef_out &operator= (const AliasDef_var &);
+  AliasDef_out &operator= (AliasDef_ptr);
+  operator AliasDef_ptr &();
+  AliasDef_ptr &ptr (void);
+  AliasDef_ptr operator-> (void);
+  
+private:
+  AliasDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ENUMDEF_CH_)
-#define _CORBA_ENUMDEF_CH_
+#if !defined (_IR_ALIASDEF_CH_)
+#define _IR_ALIASDEF_CH_
+
+class TAO_Export AliasDef: public virtual TypedefDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef AliasDef_ptr _ptr_type;
+  typedef AliasDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-class TAO_Export CORBA_EnumDef: public virtual CORBA_TypedefDef
+  // the static operations
+  static AliasDef_ptr _duplicate (AliasDef_ptr obj);
+  static AliasDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static AliasDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static AliasDef_ptr _nil (void)
+    {
+      return (AliasDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::IDLType_ptr original_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void original_type_def (
+      IR::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  AliasDef (void);
+  AliasDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~AliasDef (void);
+private:
+  AliasDef (const AliasDef &);
+  void operator= (const AliasDef &);
+};
+
+class TAO_IR_AliasDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_AliasDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_AliasDef_Default_Proxy_Factory (void);
+  
+  virtual AliasDef_ptr create_proxy (
+      AliasDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_AliasDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_AliasDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_AliasDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  AliasDef_ptr create_proxy (
+      AliasDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_AliasDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_AliasDef_Proxy_Factory_Adapter (void);
+  TAO_IR_AliasDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_AliasDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_AliasDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_AliasDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_AliasDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_AliasDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, AliasDef)
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_EnumDef_ptr _ptr_type;
-    typedef CORBA_EnumDef_var _var_type;
-  #endif /* __GNUC__ */
+    TAO_IR_AliasDef_Smart_Proxy_Base (::IR::AliasDef_ptr proxy);
+    ~TAO_IR_AliasDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::IDLType_ptr original_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void original_type_def (
+      IR::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::AliasDef_var base_proxy_;
+};
 
-    // the static operations
-    static CORBA_EnumDef_ptr _duplicate (CORBA_EnumDef_ptr obj);
-    static CORBA_EnumDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_EnumDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_EnumDef_ptr _nil (void)
-      {
-        return (CORBA::EnumDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA_EnumMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual void members (
-        const CORBA_EnumMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AliasDef;
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
 
-  protected:
-    CORBA_EnumDef (void);
-    CORBA_EnumDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_EnumDef (void);
-  private:
-    CORBA_EnumDef (const CORBA_EnumDef &);
-    void operator= (const CORBA_EnumDef &);
-  };
+#if !defined (_IR_NATIVEDEF___PTR_CH_)
+#define _IR_NATIVEDEF___PTR_CH_
 
+class NativeDef;
+typedef NativeDef *NativeDef_ptr;
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_ALIASDEF___VAR_CH_)
-#define _CORBA_ALIASDEF___VAR_CH_
 
-  class TAO_Export CORBA_AliasDef_var
-  {
-  public:
-    CORBA_AliasDef_var (void); // default constructor
-    CORBA_AliasDef_var (CORBA_AliasDef_ptr);
-    CORBA_AliasDef_var (const CORBA_AliasDef_var &); // copy constructor
-    ~CORBA_AliasDef_var (void); // destructor
+#if !defined (_IR_NATIVEDEF___VAR_CH_)
+#define _IR_NATIVEDEF___VAR_CH_
+
+class TAO_Export NativeDef_var
+{
+public:
+  NativeDef_var (void); // default constructor
+  NativeDef_var (NativeDef_ptr);
+  NativeDef_var (const NativeDef_var &); // copy constructor
+  ~NativeDef_var (void); // destructor
+  
+  NativeDef_var &operator= (NativeDef_ptr);
+  NativeDef_var &operator= (const NativeDef_var &);
+  NativeDef_ptr operator-> (void) const;
+  
+  operator const NativeDef_ptr &() const;
+  operator NativeDef_ptr &();
+  // in, inout, out, _retn 
+  NativeDef_ptr in (void) const;
+  NativeDef_ptr &inout (void);
+  NativeDef_ptr &out (void);
+  NativeDef_ptr _retn (void);
+  NativeDef_ptr ptr (void) const;
+
+private:
+  NativeDef_ptr ptr_;
+};
 
-    CORBA_AliasDef_var &operator= (CORBA_AliasDef_ptr);
-    CORBA_AliasDef_var &operator= (const CORBA_AliasDef_var &);
-    CORBA_AliasDef_ptr operator-> (void) const;
 
-    operator const CORBA_AliasDef_ptr &() const;
-    operator CORBA_AliasDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_AliasDef_ptr in (void) const;
-    CORBA_AliasDef_ptr &inout (void);
-    CORBA_AliasDef_ptr &out (void);
-    CORBA_AliasDef_ptr _retn (void);
-    CORBA_AliasDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_AliasDef_ptr ptr_;
-  };
+
+#if !defined (_IR_NATIVEDEF___OUT_CH_)
+#define _IR_NATIVEDEF___OUT_CH_
+
+class TAO_Export NativeDef_out
+{
+public:
+  NativeDef_out (NativeDef_ptr &);
+  NativeDef_out (NativeDef_var &);
+  NativeDef_out (const NativeDef_out &);
+  NativeDef_out &operator= (const NativeDef_out &);
+  NativeDef_out &operator= (const NativeDef_var &);
+  NativeDef_out &operator= (NativeDef_ptr);
+  operator NativeDef_ptr &();
+  NativeDef_ptr &ptr (void);
+  NativeDef_ptr operator-> (void);
+  
+private:
+  NativeDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ALIASDEF___OUT_CH_)
-#define _CORBA_ALIASDEF___OUT_CH_
+#if !defined (_IR_NATIVEDEF_CH_)
+#define _IR_NATIVEDEF_CH_
 
-  class TAO_Export CORBA_AliasDef_out
-  {
-  public:
-    CORBA_AliasDef_out (CORBA_AliasDef_ptr &);
-    CORBA_AliasDef_out (CORBA_AliasDef_var &);
-    CORBA_AliasDef_out (const CORBA_AliasDef_out &);
-    CORBA_AliasDef_out &operator= (const CORBA_AliasDef_out &);
-    CORBA_AliasDef_out &operator= (const CORBA_AliasDef_var &);
-    CORBA_AliasDef_out &operator= (CORBA_AliasDef_ptr);
-    operator CORBA_AliasDef_ptr &();
-    CORBA_AliasDef_ptr &ptr (void);
-    CORBA_AliasDef_ptr operator-> (void);
+class TAO_Export NativeDef: public virtual TypedefDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef NativeDef_ptr _ptr_type;
+  typedef NativeDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  private:
-    CORBA_AliasDef_ptr &ptr_;
-  };
+  // the static operations
+  static NativeDef_ptr _duplicate (NativeDef_ptr obj);
+  static NativeDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static NativeDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static NativeDef_ptr _nil (void)
+    {
+      return (NativeDef_ptr)0;
+    }
 
+  static void _tao_any_destructor (void*);
 
-#endif /* end #if !defined */
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
 
+protected:
+  NativeDef (void);
+  NativeDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~NativeDef (void);
+private:
+  NativeDef (const NativeDef &);
+  void operator= (const NativeDef &);
+};
+
+class TAO_IR_NativeDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_NativeDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_NativeDef_Default_Proxy_Factory (void);
+  
+  virtual NativeDef_ptr create_proxy (
+      NativeDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_NativeDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_NativeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_NativeDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  NativeDef_ptr create_proxy (
+      NativeDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
 
-#if !defined (_CORBA_ALIASDEF_CH_)
-#define _CORBA_ALIASDEF_CH_
+protected:
+  TAO_IR_NativeDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_NativeDef_Proxy_Factory_Adapter (void);
+  TAO_IR_NativeDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_NativeDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_NativeDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
 
-class TAO_Export CORBA_AliasDef: public virtual CORBA_TypedefDef
+  typedef ACE_Singleton<TAO_IR_NativeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_NativeDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_NativeDef_Smart_Proxy_Base : public virtual NativeDef
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_AliasDef_ptr _ptr_type;
-    typedef CORBA_AliasDef_var _var_type;
-  #endif /* __GNUC__ */
+    TAO_IR_NativeDef_Smart_Proxy_Base (::IR::NativeDef_ptr proxy);
+    ~TAO_IR_NativeDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+    private:
+  ::IR::NativeDef_var base_proxy_;
+};
 
-    // the static operations
-    static CORBA_AliasDef_ptr _duplicate (CORBA_AliasDef_ptr obj);
-    static CORBA_AliasDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_AliasDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_AliasDef_ptr _nil (void)
-      {
-        return (CORBA::AliasDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA_IDLType_ptr original_type_def (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual void original_type_def (
-        CORBA_IDLType_ptr original_type_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_NativeDef;
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
 
-  protected:
-    CORBA_AliasDef (void);
-    CORBA_AliasDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_AliasDef (void);
-  private:
-    CORBA_AliasDef (const CORBA_AliasDef &);
-    void operator= (const CORBA_AliasDef &);
-  };
+#if !defined (_IR_PRIMITIVEDEF___PTR_CH_)
+#define _IR_PRIMITIVEDEF___PTR_CH_
 
+class PrimitiveDef;
+typedef PrimitiveDef *PrimitiveDef_ptr;
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_PRIMITIVEDEF___VAR_CH_)
-#define _CORBA_PRIMITIVEDEF___VAR_CH_
 
-  class TAO_Export CORBA_PrimitiveDef_var
-  {
-  public:
-    CORBA_PrimitiveDef_var (void); // default constructor
-    CORBA_PrimitiveDef_var (CORBA_PrimitiveDef_ptr);
-    CORBA_PrimitiveDef_var (const CORBA_PrimitiveDef_var &); // copy constructor
-    ~CORBA_PrimitiveDef_var (void); // destructor
+#if !defined (_IR_PRIMITIVEDEF___VAR_CH_)
+#define _IR_PRIMITIVEDEF___VAR_CH_
+
+class TAO_Export PrimitiveDef_var
+{
+public:
+  PrimitiveDef_var (void); // default constructor
+  PrimitiveDef_var (PrimitiveDef_ptr);
+  PrimitiveDef_var (const PrimitiveDef_var &); // copy constructor
+  ~PrimitiveDef_var (void); // destructor
+  
+  PrimitiveDef_var &operator= (PrimitiveDef_ptr);
+  PrimitiveDef_var &operator= (const PrimitiveDef_var &);
+  PrimitiveDef_ptr operator-> (void) const;
+  
+  operator const PrimitiveDef_ptr &() const;
+  operator PrimitiveDef_ptr &();
+  // in, inout, out, _retn 
+  PrimitiveDef_ptr in (void) const;
+  PrimitiveDef_ptr &inout (void);
+  PrimitiveDef_ptr &out (void);
+  PrimitiveDef_ptr _retn (void);
+  PrimitiveDef_ptr ptr (void) const;
+
+private:
+  PrimitiveDef_ptr ptr_;
+};
 
-    CORBA_PrimitiveDef_var &operator= (CORBA_PrimitiveDef_ptr);
-    CORBA_PrimitiveDef_var &operator= (const CORBA_PrimitiveDef_var &);
-    CORBA_PrimitiveDef_ptr operator-> (void) const;
 
-    operator const CORBA_PrimitiveDef_ptr &() const;
-    operator CORBA_PrimitiveDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_PrimitiveDef_ptr in (void) const;
-    CORBA_PrimitiveDef_ptr &inout (void);
-    CORBA_PrimitiveDef_ptr &out (void);
-    CORBA_PrimitiveDef_ptr _retn (void);
-    CORBA_PrimitiveDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_PrimitiveDef_ptr ptr_;
-  };
+
+#if !defined (_IR_PRIMITIVEDEF___OUT_CH_)
+#define _IR_PRIMITIVEDEF___OUT_CH_
+
+class TAO_Export PrimitiveDef_out
+{
+public:
+  PrimitiveDef_out (PrimitiveDef_ptr &);
+  PrimitiveDef_out (PrimitiveDef_var &);
+  PrimitiveDef_out (const PrimitiveDef_out &);
+  PrimitiveDef_out &operator= (const PrimitiveDef_out &);
+  PrimitiveDef_out &operator= (const PrimitiveDef_var &);
+  PrimitiveDef_out &operator= (PrimitiveDef_ptr);
+  operator PrimitiveDef_ptr &();
+  PrimitiveDef_ptr &ptr (void);
+  PrimitiveDef_ptr operator-> (void);
+  
+private:
+  PrimitiveDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_PRIMITIVEDEF___OUT_CH_)
-#define _CORBA_PRIMITIVEDEF___OUT_CH_
+#if !defined (_IR_PRIMITIVEDEF_CH_)
+#define _IR_PRIMITIVEDEF_CH_
+
+class TAO_Export PrimitiveDef: public virtual IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef PrimitiveDef_ptr _ptr_type;
+  typedef PrimitiveDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static PrimitiveDef_ptr _duplicate (PrimitiveDef_ptr obj);
+  static PrimitiveDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static PrimitiveDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static PrimitiveDef_ptr _nil (void)
+    {
+      return (PrimitiveDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::PrimitiveKind kind (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  PrimitiveDef (void);
+  PrimitiveDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~PrimitiveDef (void);
+private:
+  PrimitiveDef (const PrimitiveDef &);
+  void operator= (const PrimitiveDef &);
+};
+
+class TAO_IR_PrimitiveDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_PrimitiveDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_PrimitiveDef_Default_Proxy_Factory (void);
+  
+  virtual PrimitiveDef_ptr create_proxy (
+      PrimitiveDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_PrimitiveDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_PrimitiveDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_PrimitiveDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  PrimitiveDef_ptr create_proxy (
+      PrimitiveDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_PrimitiveDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_PrimitiveDef_Proxy_Factory_Adapter (void);
+  TAO_IR_PrimitiveDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_PrimitiveDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_PrimitiveDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
 
-  class TAO_Export CORBA_PrimitiveDef_out
+  typedef ACE_Singleton<TAO_IR_PrimitiveDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_PrimitiveDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_PrimitiveDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, PrimitiveDef)
   {
   public:
-    CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_ptr &);
-    CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_var &);
-    CORBA_PrimitiveDef_out (const CORBA_PrimitiveDef_out &);
-    CORBA_PrimitiveDef_out &operator= (const CORBA_PrimitiveDef_out &);
-    CORBA_PrimitiveDef_out &operator= (const CORBA_PrimitiveDef_var &);
-    CORBA_PrimitiveDef_out &operator= (CORBA_PrimitiveDef_ptr);
-    operator CORBA_PrimitiveDef_ptr &();
-    CORBA_PrimitiveDef_ptr &ptr (void);
-    CORBA_PrimitiveDef_ptr operator-> (void);
+    TAO_IR_PrimitiveDef_Smart_Proxy_Base (::IR::PrimitiveDef_ptr proxy);
+    ~TAO_IR_PrimitiveDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::PrimitiveKind kind (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::PrimitiveDef_var base_proxy_;
+};
+
+
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveDef;
 
-  private:
-    CORBA_PrimitiveDef_ptr &ptr_;
-  };
 
+#if !defined (_IR_STRINGDEF___PTR_CH_)
+#define _IR_STRINGDEF___PTR_CH_
+
+class StringDef;
+typedef StringDef *StringDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_PRIMITIVEDEF_CH_)
-#define _CORBA_PRIMITIVEDEF_CH_
+#if !defined (_IR_STRINGDEF___VAR_CH_)
+#define _IR_STRINGDEF___VAR_CH_
+
+class TAO_Export StringDef_var
+{
+public:
+  StringDef_var (void); // default constructor
+  StringDef_var (StringDef_ptr);
+  StringDef_var (const StringDef_var &); // copy constructor
+  ~StringDef_var (void); // destructor
+  
+  StringDef_var &operator= (StringDef_ptr);
+  StringDef_var &operator= (const StringDef_var &);
+  StringDef_ptr operator-> (void) const;
+  
+  operator const StringDef_ptr &() const;
+  operator StringDef_ptr &();
+  // in, inout, out, _retn 
+  StringDef_ptr in (void) const;
+  StringDef_ptr &inout (void);
+  StringDef_ptr &out (void);
+  StringDef_ptr _retn (void);
+  StringDef_ptr ptr (void) const;
+
+private:
+  StringDef_ptr ptr_;
+};
 
-class TAO_Export CORBA_PrimitiveDef: public virtual CORBA_IDLType
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_PrimitiveDef_ptr _ptr_type;
-    typedef CORBA_PrimitiveDef_var _var_type;
-  #endif /* __GNUC__ */
 
-    // the static operations
-    static CORBA_PrimitiveDef_ptr _duplicate (CORBA_PrimitiveDef_ptr obj);
-    static CORBA_PrimitiveDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_PrimitiveDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_PrimitiveDef_ptr _nil (void)
-      {
-        return (CORBA::PrimitiveDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+#endif /* end #if !defined */
 
-    virtual CORBA::PrimitiveKind kind (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+#if !defined (_IR_STRINGDEF___OUT_CH_)
+#define _IR_STRINGDEF___OUT_CH_
 
-  protected:
-    CORBA_PrimitiveDef (void);
-    CORBA_PrimitiveDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_PrimitiveDef (void);
-  private:
-    CORBA_PrimitiveDef (const CORBA_PrimitiveDef &);
-    void operator= (const CORBA_PrimitiveDef &);
-  };
+class TAO_Export StringDef_out
+{
+public:
+  StringDef_out (StringDef_ptr &);
+  StringDef_out (StringDef_var &);
+  StringDef_out (const StringDef_out &);
+  StringDef_out &operator= (const StringDef_out &);
+  StringDef_out &operator= (const StringDef_var &);
+  StringDef_out &operator= (StringDef_ptr);
+  operator StringDef_ptr &();
+  StringDef_ptr &ptr (void);
+  StringDef_ptr operator-> (void);
+  
+private:
+  StringDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRINGDEF___VAR_CH_)
-#define _CORBA_STRINGDEF___VAR_CH_
+#if !defined (_IR_STRINGDEF_CH_)
+#define _IR_STRINGDEF_CH_
+
+class TAO_Export StringDef: public virtual IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef StringDef_ptr _ptr_type;
+  typedef StringDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static StringDef_ptr _duplicate (StringDef_ptr obj);
+  static StringDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static StringDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static StringDef_ptr _nil (void)
+    {
+      return (StringDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::ULong bound (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  StringDef (void);
+  StringDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~StringDef (void);
+private:
+  StringDef (const StringDef &);
+  void operator= (const StringDef &);
+};
+
+class TAO_IR_StringDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_StringDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_StringDef_Default_Proxy_Factory (void);
+  
+  virtual StringDef_ptr create_proxy (
+      StringDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_StringDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_StringDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_StringDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  StringDef_ptr create_proxy (
+      StringDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_StringDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_StringDef_Proxy_Factory_Adapter (void);
+  TAO_IR_StringDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_StringDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_StringDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
 
-  class TAO_Export CORBA_StringDef_var
+  typedef ACE_Singleton<TAO_IR_StringDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_StringDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_StringDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, StringDef)
   {
   public:
-    CORBA_StringDef_var (void); // default constructor
-    CORBA_StringDef_var (CORBA_StringDef_ptr);
-    CORBA_StringDef_var (const CORBA_StringDef_var &); // copy constructor
-    ~CORBA_StringDef_var (void); // destructor
+    TAO_IR_StringDef_Smart_Proxy_Base (::IR::StringDef_ptr proxy);
+    ~TAO_IR_StringDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::ULong bound (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::StringDef_var base_proxy_;
+};
 
-    CORBA_StringDef_var &operator= (CORBA_StringDef_ptr);
-    CORBA_StringDef_var &operator= (const CORBA_StringDef_var &);
-    CORBA_StringDef_ptr operator-> (void) const;
 
-    operator const CORBA_StringDef_ptr &() const;
-    operator CORBA_StringDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_StringDef_ptr in (void) const;
-    CORBA_StringDef_ptr &inout (void);
-    CORBA_StringDef_ptr &out (void);
-    CORBA_StringDef_ptr _retn (void);
-    CORBA_StringDef_ptr ptr (void) const;
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StringDef;
 
-  private:
-    CORBA_StringDef_ptr ptr_;
-  };
 
+#if !defined (_IR_WSTRINGDEF___PTR_CH_)
+#define _IR_WSTRINGDEF___PTR_CH_
+
+class WstringDef;
+typedef WstringDef *WstringDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRINGDEF___OUT_CH_)
-#define _CORBA_STRINGDEF___OUT_CH_
+#if !defined (_IR_WSTRINGDEF___VAR_CH_)
+#define _IR_WSTRINGDEF___VAR_CH_
+
+class TAO_Export WstringDef_var
+{
+public:
+  WstringDef_var (void); // default constructor
+  WstringDef_var (WstringDef_ptr);
+  WstringDef_var (const WstringDef_var &); // copy constructor
+  ~WstringDef_var (void); // destructor
+  
+  WstringDef_var &operator= (WstringDef_ptr);
+  WstringDef_var &operator= (const WstringDef_var &);
+  WstringDef_ptr operator-> (void) const;
+  
+  operator const WstringDef_ptr &() const;
+  operator WstringDef_ptr &();
+  // in, inout, out, _retn 
+  WstringDef_ptr in (void) const;
+  WstringDef_ptr &inout (void);
+  WstringDef_ptr &out (void);
+  WstringDef_ptr _retn (void);
+  WstringDef_ptr ptr (void) const;
+
+private:
+  WstringDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_StringDef_out
-  {
-  public:
-    CORBA_StringDef_out (CORBA_StringDef_ptr &);
-    CORBA_StringDef_out (CORBA_StringDef_var &);
-    CORBA_StringDef_out (const CORBA_StringDef_out &);
-    CORBA_StringDef_out &operator= (const CORBA_StringDef_out &);
-    CORBA_StringDef_out &operator= (const CORBA_StringDef_var &);
-    CORBA_StringDef_out &operator= (CORBA_StringDef_ptr);
-    operator CORBA_StringDef_ptr &();
-    CORBA_StringDef_ptr &ptr (void);
-    CORBA_StringDef_ptr operator-> (void);
 
-  private:
-    CORBA_StringDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_WSTRINGDEF___OUT_CH_)
+#define _IR_WSTRINGDEF___OUT_CH_
+
+class TAO_Export WstringDef_out
+{
+public:
+  WstringDef_out (WstringDef_ptr &);
+  WstringDef_out (WstringDef_var &);
+  WstringDef_out (const WstringDef_out &);
+  WstringDef_out &operator= (const WstringDef_out &);
+  WstringDef_out &operator= (const WstringDef_var &);
+  WstringDef_out &operator= (WstringDef_ptr);
+  operator WstringDef_ptr &();
+  WstringDef_ptr &ptr (void);
+  WstringDef_ptr operator-> (void);
+  
+private:
+  WstringDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRINGDEF_CH_)
-#define _CORBA_STRINGDEF_CH_
+#if !defined (_IR_WSTRINGDEF_CH_)
+#define _IR_WSTRINGDEF_CH_
+
+class TAO_Export WstringDef: public virtual IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef WstringDef_ptr _ptr_type;
+  typedef WstringDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static WstringDef_ptr _duplicate (WstringDef_ptr obj);
+  static WstringDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static WstringDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static WstringDef_ptr _nil (void)
+    {
+      return (WstringDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::ULong bound (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  WstringDef (void);
+  WstringDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~WstringDef (void);
+private:
+  WstringDef (const WstringDef &);
+  void operator= (const WstringDef &);
+};
+
+class TAO_IR_WstringDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_WstringDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_WstringDef_Default_Proxy_Factory (void);
+  
+  virtual WstringDef_ptr create_proxy (
+      WstringDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_WstringDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_WstringDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_WstringDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  WstringDef_ptr create_proxy (
+      WstringDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_WstringDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_WstringDef_Proxy_Factory_Adapter (void);
+  TAO_IR_WstringDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_WstringDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_WstringDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
 
-class TAO_Export CORBA_StringDef: public virtual CORBA_IDLType
+  typedef ACE_Singleton<TAO_IR_WstringDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_WstringDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_WstringDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, WstringDef)
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_StringDef_ptr _ptr_type;
-    typedef CORBA_StringDef_var _var_type;
-  #endif /* __GNUC__ */
+    TAO_IR_WstringDef_Smart_Proxy_Base (::IR::WstringDef_ptr proxy);
+    ~TAO_IR_WstringDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::ULong bound (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::WstringDef_var base_proxy_;
+};
 
-    // the static operations
-    static CORBA_StringDef_ptr _duplicate (CORBA_StringDef_ptr obj);
-    static CORBA_StringDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_StringDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_StringDef_ptr _nil (void)
-      {
-        return (CORBA::StringDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA::ULong bound (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual void bound (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_WstringDef;
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
 
-  protected:
-    CORBA_StringDef (void);
-    CORBA_StringDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_StringDef (void);
-  private:
-    CORBA_StringDef (const CORBA_StringDef &);
-    void operator= (const CORBA_StringDef &);
-  };
+#if !defined (_IR_FIXEDDEF___PTR_CH_)
+#define _IR_FIXEDDEF___PTR_CH_
 
+class FixedDef;
+typedef FixedDef *FixedDef_ptr;
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_WSTRINGDEF___VAR_CH_)
-#define _CORBA_WSTRINGDEF___VAR_CH_
 
-  class TAO_Export CORBA_WstringDef_var
-  {
-  public:
-    CORBA_WstringDef_var (void); // default constructor
-    CORBA_WstringDef_var (CORBA_WstringDef_ptr);
-    CORBA_WstringDef_var (const CORBA_WstringDef_var &); // copy constructor
-    ~CORBA_WstringDef_var (void); // destructor
+#if !defined (_IR_FIXEDDEF___VAR_CH_)
+#define _IR_FIXEDDEF___VAR_CH_
+
+class TAO_Export FixedDef_var
+{
+public:
+  FixedDef_var (void); // default constructor
+  FixedDef_var (FixedDef_ptr);
+  FixedDef_var (const FixedDef_var &); // copy constructor
+  ~FixedDef_var (void); // destructor
+  
+  FixedDef_var &operator= (FixedDef_ptr);
+  FixedDef_var &operator= (const FixedDef_var &);
+  FixedDef_ptr operator-> (void) const;
+  
+  operator const FixedDef_ptr &() const;
+  operator FixedDef_ptr &();
+  // in, inout, out, _retn 
+  FixedDef_ptr in (void) const;
+  FixedDef_ptr &inout (void);
+  FixedDef_ptr &out (void);
+  FixedDef_ptr _retn (void);
+  FixedDef_ptr ptr (void) const;
+
+private:
+  FixedDef_ptr ptr_;
+};
 
-    CORBA_WstringDef_var &operator= (CORBA_WstringDef_ptr);
-    CORBA_WstringDef_var &operator= (const CORBA_WstringDef_var &);
-    CORBA_WstringDef_ptr operator-> (void) const;
 
-    operator const CORBA_WstringDef_ptr &() const;
-    operator CORBA_WstringDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_WstringDef_ptr in (void) const;
-    CORBA_WstringDef_ptr &inout (void);
-    CORBA_WstringDef_ptr &out (void);
-    CORBA_WstringDef_ptr _retn (void);
-    CORBA_WstringDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_WstringDef_ptr ptr_;
-  };
+
+#if !defined (_IR_FIXEDDEF___OUT_CH_)
+#define _IR_FIXEDDEF___OUT_CH_
+
+class TAO_Export FixedDef_out
+{
+public:
+  FixedDef_out (FixedDef_ptr &);
+  FixedDef_out (FixedDef_var &);
+  FixedDef_out (const FixedDef_out &);
+  FixedDef_out &operator= (const FixedDef_out &);
+  FixedDef_out &operator= (const FixedDef_var &);
+  FixedDef_out &operator= (FixedDef_ptr);
+  operator FixedDef_ptr &();
+  FixedDef_ptr &ptr (void);
+  FixedDef_ptr operator-> (void);
+  
+private:
+  FixedDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_WSTRINGDEF___OUT_CH_)
-#define _CORBA_WSTRINGDEF___OUT_CH_
+#if !defined (_IR_FIXEDDEF_CH_)
+#define _IR_FIXEDDEF_CH_
 
-  class TAO_Export CORBA_WstringDef_out
-  {
-  public:
-    CORBA_WstringDef_out (CORBA_WstringDef_ptr &);
-    CORBA_WstringDef_out (CORBA_WstringDef_var &);
-    CORBA_WstringDef_out (const CORBA_WstringDef_out &);
-    CORBA_WstringDef_out &operator= (const CORBA_WstringDef_out &);
-    CORBA_WstringDef_out &operator= (const CORBA_WstringDef_var &);
-    CORBA_WstringDef_out &operator= (CORBA_WstringDef_ptr);
-    operator CORBA_WstringDef_ptr &();
-    CORBA_WstringDef_ptr &ptr (void);
-    CORBA_WstringDef_ptr operator-> (void);
+class TAO_Export FixedDef: public virtual IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef FixedDef_ptr _ptr_type;
+  typedef FixedDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  private:
-    CORBA_WstringDef_ptr &ptr_;
+  // the static operations
+  static FixedDef_ptr _duplicate (FixedDef_ptr obj);
+  static FixedDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static FixedDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static FixedDef_ptr _nil (void)
+    {
+      return (FixedDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::UShort digits (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void digits (
+      CORBA::UShort digits,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Short scale (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void scale (
+      CORBA::Short scale,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  FixedDef (void);
+  FixedDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~FixedDef (void);
+private:
+  FixedDef (const FixedDef &);
+  void operator= (const FixedDef &);
+};
+
+class TAO_IR_FixedDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_FixedDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_FixedDef_Default_Proxy_Factory (void);
+  
+  virtual FixedDef_ptr create_proxy (
+      FixedDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_FixedDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_FixedDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_FixedDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  FixedDef_ptr create_proxy (
+      FixedDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_FixedDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_FixedDef_Proxy_Factory_Adapter (void);
+  TAO_IR_FixedDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_FixedDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_FixedDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
+  typedef ACE_Singleton<TAO_IR_FixedDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_FixedDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_FixedDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, FixedDef)
+  {
+  public:
+    TAO_IR_FixedDef_Smart_Proxy_Base (::IR::FixedDef_ptr proxy);
+    ~TAO_IR_FixedDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::UShort digits (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void digits (
+      CORBA::UShort digits,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Short scale (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void scale (
+      CORBA::Short scale,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::FixedDef_var base_proxy_;
+};
+
 
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FixedDef;
 
-#if !defined (_CORBA_WSTRINGDEF_CH_)
-#define _CORBA_WSTRINGDEF_CH_
 
-class TAO_Export CORBA_WstringDef: public virtual CORBA_IDLType
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_WstringDef_ptr _ptr_type;
-    typedef CORBA_WstringDef_var _var_type;
-  #endif /* __GNUC__ */
+#if !defined (_IR_SEQUENCEDEF___PTR_CH_)
+#define _IR_SEQUENCEDEF___PTR_CH_
 
-    // the static operations
-    static CORBA_WstringDef_ptr _duplicate (CORBA_WstringDef_ptr obj);
-    static CORBA_WstringDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_WstringDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_WstringDef_ptr _nil (void)
-      {
-        return (CORBA::WstringDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+class SequenceDef;
+typedef SequenceDef *SequenceDef_ptr;
 
-    virtual CORBA::ULong bound (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual void bound (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+#if !defined (_IR_SEQUENCEDEF___VAR_CH_)
+#define _IR_SEQUENCEDEF___VAR_CH_
+
+class TAO_Export SequenceDef_var
+{
+public:
+  SequenceDef_var (void); // default constructor
+  SequenceDef_var (SequenceDef_ptr);
+  SequenceDef_var (const SequenceDef_var &); // copy constructor
+  ~SequenceDef_var (void); // destructor
+  
+  SequenceDef_var &operator= (SequenceDef_ptr);
+  SequenceDef_var &operator= (const SequenceDef_var &);
+  SequenceDef_ptr operator-> (void) const;
+  
+  operator const SequenceDef_ptr &() const;
+  operator SequenceDef_ptr &();
+  // in, inout, out, _retn 
+  SequenceDef_ptr in (void) const;
+  SequenceDef_ptr &inout (void);
+  SequenceDef_ptr &out (void);
+  SequenceDef_ptr _retn (void);
+  SequenceDef_ptr ptr (void) const;
+
+private:
+  SequenceDef_ptr ptr_;
+};
 
-  protected:
-    CORBA_WstringDef (void);
-    CORBA_WstringDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_WstringDef (void);
-  private:
-    CORBA_WstringDef (const CORBA_WstringDef &);
-    void operator= (const CORBA_WstringDef &);
-  };
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_SEQUENCEDEF___OUT_CH_)
+#define _IR_SEQUENCEDEF___OUT_CH_
+
+class TAO_Export SequenceDef_out
+{
+public:
+  SequenceDef_out (SequenceDef_ptr &);
+  SequenceDef_out (SequenceDef_var &);
+  SequenceDef_out (const SequenceDef_out &);
+  SequenceDef_out &operator= (const SequenceDef_out &);
+  SequenceDef_out &operator= (const SequenceDef_var &);
+  SequenceDef_out &operator= (SequenceDef_ptr);
+  operator SequenceDef_ptr &();
+  SequenceDef_ptr &ptr (void);
+  SequenceDef_ptr operator-> (void);
+  
+private:
+  SequenceDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_FIXEDDEF___VAR_CH_)
-#define _CORBA_FIXEDDEF___VAR_CH_
+#if !defined (_IR_SEQUENCEDEF_CH_)
+#define _IR_SEQUENCEDEF_CH_
 
-  class TAO_Export CORBA_FixedDef_var
+class TAO_Export SequenceDef: public virtual IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef SequenceDef_ptr _ptr_type;
+  typedef SequenceDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static SequenceDef_ptr _duplicate (SequenceDef_ptr obj);
+  static SequenceDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static SequenceDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static SequenceDef_ptr _nil (void)
+    {
+      return (SequenceDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::ULong bound (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr element_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void element_type_def (
+      IR::IDLType_ptr element_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  SequenceDef (void);
+  SequenceDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~SequenceDef (void);
+private:
+  SequenceDef (const SequenceDef &);
+  void operator= (const SequenceDef &);
+};
+
+class TAO_IR_SequenceDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_SequenceDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_SequenceDef_Default_Proxy_Factory (void);
+  
+  virtual SequenceDef_ptr create_proxy (
+      SequenceDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_SequenceDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_SequenceDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_SequenceDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  SequenceDef_ptr create_proxy (
+      SequenceDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_SequenceDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_SequenceDef_Proxy_Factory_Adapter (void);
+  TAO_IR_SequenceDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_SequenceDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_SequenceDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_SequenceDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_SequenceDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_SequenceDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, SequenceDef)
   {
   public:
-    CORBA_FixedDef_var (void); // default constructor
-    CORBA_FixedDef_var (CORBA_FixedDef_ptr);
-    CORBA_FixedDef_var (const CORBA_FixedDef_var &); // copy constructor
-    ~CORBA_FixedDef_var (void); // destructor
+    TAO_IR_SequenceDef_Smart_Proxy_Base (::IR::SequenceDef_ptr proxy);
+    ~TAO_IR_SequenceDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::ULong bound (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void bound (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr element_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void element_type_def (
+      IR::IDLType_ptr element_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::SequenceDef_var base_proxy_;
+};
 
-    CORBA_FixedDef_var &operator= (CORBA_FixedDef_ptr);
-    CORBA_FixedDef_var &operator= (const CORBA_FixedDef_var &);
-    CORBA_FixedDef_ptr operator-> (void) const;
 
-    operator const CORBA_FixedDef_ptr &() const;
-    operator CORBA_FixedDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_FixedDef_ptr in (void) const;
-    CORBA_FixedDef_ptr &inout (void);
-    CORBA_FixedDef_ptr &out (void);
-    CORBA_FixedDef_ptr _retn (void);
-    CORBA_FixedDef_ptr ptr (void) const;
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SequenceDef;
 
-  private:
-    CORBA_FixedDef_ptr ptr_;
-  };
 
+#if !defined (_IR_ARRAYDEF___PTR_CH_)
+#define _IR_ARRAYDEF___PTR_CH_
+
+class ArrayDef;
+typedef ArrayDef *ArrayDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_FIXEDDEF___OUT_CH_)
-#define _CORBA_FIXEDDEF___OUT_CH_
+#if !defined (_IR_ARRAYDEF___VAR_CH_)
+#define _IR_ARRAYDEF___VAR_CH_
+
+class TAO_Export ArrayDef_var
+{
+public:
+  ArrayDef_var (void); // default constructor
+  ArrayDef_var (ArrayDef_ptr);
+  ArrayDef_var (const ArrayDef_var &); // copy constructor
+  ~ArrayDef_var (void); // destructor
+  
+  ArrayDef_var &operator= (ArrayDef_ptr);
+  ArrayDef_var &operator= (const ArrayDef_var &);
+  ArrayDef_ptr operator-> (void) const;
+  
+  operator const ArrayDef_ptr &() const;
+  operator ArrayDef_ptr &();
+  // in, inout, out, _retn 
+  ArrayDef_ptr in (void) const;
+  ArrayDef_ptr &inout (void);
+  ArrayDef_ptr &out (void);
+  ArrayDef_ptr _retn (void);
+  ArrayDef_ptr ptr (void) const;
+
+private:
+  ArrayDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_FixedDef_out
-  {
-  public:
-    CORBA_FixedDef_out (CORBA_FixedDef_ptr &);
-    CORBA_FixedDef_out (CORBA_FixedDef_var &);
-    CORBA_FixedDef_out (const CORBA_FixedDef_out &);
-    CORBA_FixedDef_out &operator= (const CORBA_FixedDef_out &);
-    CORBA_FixedDef_out &operator= (const CORBA_FixedDef_var &);
-    CORBA_FixedDef_out &operator= (CORBA_FixedDef_ptr);
-    operator CORBA_FixedDef_ptr &();
-    CORBA_FixedDef_ptr &ptr (void);
-    CORBA_FixedDef_ptr operator-> (void);
 
-  private:
-    CORBA_FixedDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_ARRAYDEF___OUT_CH_)
+#define _IR_ARRAYDEF___OUT_CH_
+
+class TAO_Export ArrayDef_out
+{
+public:
+  ArrayDef_out (ArrayDef_ptr &);
+  ArrayDef_out (ArrayDef_var &);
+  ArrayDef_out (const ArrayDef_out &);
+  ArrayDef_out &operator= (const ArrayDef_out &);
+  ArrayDef_out &operator= (const ArrayDef_var &);
+  ArrayDef_out &operator= (ArrayDef_ptr);
+  operator ArrayDef_ptr &();
+  ArrayDef_ptr &ptr (void);
+  ArrayDef_ptr operator-> (void);
+  
+private:
+  ArrayDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_FIXEDDEF_CH_)
-#define _CORBA_FIXEDDEF_CH_
+#if !defined (_IR_ARRAYDEF_CH_)
+#define _IR_ARRAYDEF_CH_
+
+class TAO_Export ArrayDef: public virtual IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ArrayDef_ptr _ptr_type;
+  typedef ArrayDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-class TAO_Export CORBA_FixedDef: public virtual CORBA_IDLType
+  // the static operations
+  static ArrayDef_ptr _duplicate (ArrayDef_ptr obj);
+  static ArrayDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ArrayDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ArrayDef_ptr _nil (void)
+    {
+      return (ArrayDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::ULong length (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void length (
+      CORBA::ULong length,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr element_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void element_type_def (
+      IR::IDLType_ptr element_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  ArrayDef (void);
+  ArrayDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ArrayDef (void);
+private:
+  ArrayDef (const ArrayDef &);
+  void operator= (const ArrayDef &);
+};
+
+class TAO_IR_ArrayDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ArrayDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ArrayDef_Default_Proxy_Factory (void);
+  
+  virtual ArrayDef_ptr create_proxy (
+      ArrayDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ArrayDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ArrayDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ArrayDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ArrayDef_ptr create_proxy (
+      ArrayDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ArrayDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ArrayDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ArrayDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ArrayDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ArrayDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_ArrayDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ArrayDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ArrayDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, ArrayDef)
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_FixedDef_ptr _ptr_type;
-    typedef CORBA_FixedDef_var _var_type;
-  #endif /* __GNUC__ */
+    TAO_IR_ArrayDef_Smart_Proxy_Base (::IR::ArrayDef_ptr proxy);
+    ~TAO_IR_ArrayDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::ULong length (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void length (
+      CORBA::ULong length,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr element_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr element_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void element_type_def (
+      IR::IDLType_ptr element_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::ArrayDef_var base_proxy_;
+};
 
-    // the static operations
-    static CORBA_FixedDef_ptr _duplicate (CORBA_FixedDef_ptr obj);
-    static CORBA_FixedDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_FixedDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_FixedDef_ptr _nil (void)
-      {
-        return (CORBA::FixedDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA::UShort digits (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual void digits (
-        CORBA::UShort digits,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ArrayDef;
 
-    virtual CORBA::Short scale (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual void scale (
-        CORBA::Short scale,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_EXCEPTIONDEF___PTR_CH_)
+#define _IR_EXCEPTIONDEF___PTR_CH_
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+class ExceptionDef;
+typedef ExceptionDef *ExceptionDef_ptr;
 
-  protected:
-    CORBA_FixedDef (void);
-    CORBA_FixedDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_FixedDef (void);
-  private:
-    CORBA_FixedDef (const CORBA_FixedDef &);
-    void operator= (const CORBA_FixedDef &);
-  };
+#endif /* end #if !defined */
 
 
-#endif /* end #if !defined */
+#if !defined (_IR_EXCEPTIONDEF___VAR_CH_)
+#define _IR_EXCEPTIONDEF___VAR_CH_
+
+class TAO_Export ExceptionDef_var
+{
+public:
+  ExceptionDef_var (void); // default constructor
+  ExceptionDef_var (ExceptionDef_ptr);
+  ExceptionDef_var (const ExceptionDef_var &); // copy constructor
+  ~ExceptionDef_var (void); // destructor
+  
+  ExceptionDef_var &operator= (ExceptionDef_ptr);
+  ExceptionDef_var &operator= (const ExceptionDef_var &);
+  ExceptionDef_ptr operator-> (void) const;
+  
+  operator const ExceptionDef_ptr &() const;
+  operator ExceptionDef_ptr &();
+  // in, inout, out, _retn 
+  ExceptionDef_ptr in (void) const;
+  ExceptionDef_ptr &inout (void);
+  ExceptionDef_ptr &out (void);
+  ExceptionDef_ptr _retn (void);
+  ExceptionDef_ptr ptr (void) const;
+
+private:
+  ExceptionDef_ptr ptr_;
+};
 
-#if !defined (_CORBA_SEQUENCEDEF___VAR_CH_)
-#define _CORBA_SEQUENCEDEF___VAR_CH_
 
-  class TAO_Export CORBA_SequenceDef_var
-  {
-  public:
-    CORBA_SequenceDef_var (void); // default constructor
-    CORBA_SequenceDef_var (CORBA_SequenceDef_ptr);
-    CORBA_SequenceDef_var (const CORBA_SequenceDef_var &); // copy constructor
-    ~CORBA_SequenceDef_var (void); // destructor
+#endif /* end #if !defined */
 
-    CORBA_SequenceDef_var &operator= (CORBA_SequenceDef_ptr);
-    CORBA_SequenceDef_var &operator= (const CORBA_SequenceDef_var &);
-    CORBA_SequenceDef_ptr operator-> (void) const;
 
-    operator const CORBA_SequenceDef_ptr &() const;
-    operator CORBA_SequenceDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_SequenceDef_ptr in (void) const;
-    CORBA_SequenceDef_ptr &inout (void);
-    CORBA_SequenceDef_ptr &out (void);
-    CORBA_SequenceDef_ptr _retn (void);
-    CORBA_SequenceDef_ptr ptr (void) const;
+#if !defined (_IR_EXCEPTIONDEF___OUT_CH_)
+#define _IR_EXCEPTIONDEF___OUT_CH_
 
-  private:
-    CORBA_SequenceDef_ptr ptr_;
-  };
+class TAO_Export ExceptionDef_out
+{
+public:
+  ExceptionDef_out (ExceptionDef_ptr &);
+  ExceptionDef_out (ExceptionDef_var &);
+  ExceptionDef_out (const ExceptionDef_out &);
+  ExceptionDef_out &operator= (const ExceptionDef_out &);
+  ExceptionDef_out &operator= (const ExceptionDef_var &);
+  ExceptionDef_out &operator= (ExceptionDef_ptr);
+  operator ExceptionDef_ptr &();
+  ExceptionDef_ptr &ptr (void);
+  ExceptionDef_ptr operator-> (void);
+  
+private:
+  ExceptionDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_SEQUENCEDEF___OUT_CH_)
-#define _CORBA_SEQUENCEDEF___OUT_CH_
+#if !defined (_IR_EXCEPTIONDEF_CH_)
+#define _IR_EXCEPTIONDEF_CH_
 
-  class TAO_Export CORBA_SequenceDef_out
-  {
-  public:
-    CORBA_SequenceDef_out (CORBA_SequenceDef_ptr &);
-    CORBA_SequenceDef_out (CORBA_SequenceDef_var &);
-    CORBA_SequenceDef_out (const CORBA_SequenceDef_out &);
-    CORBA_SequenceDef_out &operator= (const CORBA_SequenceDef_out &);
-    CORBA_SequenceDef_out &operator= (const CORBA_SequenceDef_var &);
-    CORBA_SequenceDef_out &operator= (CORBA_SequenceDef_ptr);
-    operator CORBA_SequenceDef_ptr &();
-    CORBA_SequenceDef_ptr &ptr (void);
-    CORBA_SequenceDef_ptr operator-> (void);
+class TAO_Export ExceptionDef: public virtual Contained, public virtual Container
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ExceptionDef_ptr _ptr_type;
+  typedef ExceptionDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  private:
-    CORBA_SequenceDef_ptr &ptr_;
+  // the static operations
+  static ExceptionDef_ptr _duplicate (ExceptionDef_ptr obj);
+  static ExceptionDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ExceptionDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ExceptionDef_ptr _nil (void)
+    {
+      return (ExceptionDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::StructMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const IR::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  ExceptionDef (void);
+  ExceptionDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ExceptionDef (void);
+private:
+  ExceptionDef (const ExceptionDef &);
+  void operator= (const ExceptionDef &);
+};
+
+class TAO_IR_ExceptionDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ExceptionDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ExceptionDef_Default_Proxy_Factory (void);
+  
+  virtual ExceptionDef_ptr create_proxy (
+      ExceptionDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ExceptionDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ExceptionDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ExceptionDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ExceptionDef_ptr create_proxy (
+      ExceptionDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ExceptionDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ExceptionDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ExceptionDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ExceptionDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ExceptionDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
+  typedef ACE_Singleton<TAO_IR_ExceptionDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ExceptionDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ExceptionDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, ExceptionDef)
+  {
+  public:
+    TAO_IR_ExceptionDef_Smart_Proxy_Base (::IR::ExceptionDef_ptr proxy);
+    ~TAO_IR_ExceptionDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::StructMemberSeq * members (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void members (
+      const IR::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::ExceptionDef_var base_proxy_;
+};
+
 
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDef;
+
+struct ExceptionDescription;
+class ExceptionDescription_var;
+
+struct TAO_Export ExceptionDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ExceptionDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+};
+
+class TAO_Export ExceptionDescription_var
+{
+public:
+  ExceptionDescription_var (void); // default constructor
+  ExceptionDescription_var (ExceptionDescription *);
+  ExceptionDescription_var (const ExceptionDescription_var &); // copy constructor
+  ~ExceptionDescription_var (void); // destructor
+  
+  ExceptionDescription_var &operator= (ExceptionDescription *);
+  ExceptionDescription_var &operator= (const ExceptionDescription_var &);
+  ExceptionDescription *operator-> (void);
+  const ExceptionDescription *operator-> (void) const;
+  
+  operator const ExceptionDescription &() const;
+  operator ExceptionDescription &();
+  operator ExceptionDescription &() const;
+  operator ExceptionDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const ExceptionDescription &in (void) const;
+  ExceptionDescription &inout (void);
+  ExceptionDescription *&out (void);
+  ExceptionDescription *_retn (void);
+  ExceptionDescription *ptr (void) const;
+
+private:
+  ExceptionDescription *ptr_;
+};
+
+class TAO_Export ExceptionDescription_out
+{
+public:
+  ExceptionDescription_out (ExceptionDescription *&);
+  ExceptionDescription_out (ExceptionDescription_var &);
+  ExceptionDescription_out (const ExceptionDescription_out &);
+  ExceptionDescription_out &operator= (const ExceptionDescription_out &);
+  ExceptionDescription_out &operator= (ExceptionDescription *);
+  operator ExceptionDescription *&();
+  ExceptionDescription *&ptr (void);
+  ExceptionDescription *operator-> (void);
+  
+private:
+  ExceptionDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ExceptionDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDescription;
 
-#if !defined (_CORBA_SEQUENCEDEF_CH_)
-#define _CORBA_SEQUENCEDEF_CH_
 
-class TAO_Export CORBA_SequenceDef: public virtual CORBA_IDLType
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EXCEPTIONDEFSEQ_CH_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EXCEPTIONDEFSEQ_CH_
+
+  class _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_SequenceDef_ptr _ptr_type;
-    typedef CORBA_SequenceDef_var _var_type;
-  #endif /* __GNUC__ */
-
-    // the static operations
-    static CORBA_SequenceDef_ptr _duplicate (CORBA_SequenceDef_ptr obj);
-    static CORBA_SequenceDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_SequenceDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum);
+    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      ExceptionDef* *value,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &rhs);
+    virtual ~_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (void);
+    _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &rhs);
+    TAO_Object_Manager<IR::ExceptionDef,IR::ExceptionDef_var> operator[] (CORBA::ULong index) const;
+    static ExceptionDef **allocbuf (CORBA::ULong nelems);
+    static void freebuf (ExceptionDef **buffer);
+    // The Base_Sequence functions, please see tao/Sequence.h
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    ExceptionDef* *get_buffer (CORBA::Boolean orphan = 0);
+    const ExceptionDef* *get_buffer (void) const;
+    virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
+    virtual void _downcast (
+        void* target,
+        CORBA_Object *src,
+        CORBA_Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       );
-    static CORBA_SequenceDef_ptr _nil (void)
-      {
-        return (CORBA::SequenceDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+    virtual CORBA_Object* _upcast (void *src) const;
+    
+  };
 
-    virtual CORBA::ULong bound (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual void bound (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA::TypeCode_ptr element_type (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-    virtual CORBA_IDLType_ptr element_type_def (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_EXCEPTIONDEFSEQ_CH_)
+#define _IR_EXCEPTIONDEFSEQ_CH_
 
-    virtual void element_type_def (
-        CORBA_IDLType_ptr element_type_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+class ExceptionDefSeq;
+class ExceptionDefSeq_var;
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+// *************************************************************
+// ExceptionDefSeq
+// *************************************************************
 
-  protected:
-    CORBA_SequenceDef (void);
-    CORBA_SequenceDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_SequenceDef (void);
-  private:
-    CORBA_SequenceDef (const CORBA_SequenceDef &);
-    void operator= (const CORBA_SequenceDef &);
-  };
+class TAO_Export ExceptionDefSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Object_Sequence<ExceptionDef,ExceptionDef_var>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ExceptionDefSeq (void); // default ctor
+  ExceptionDefSeq (CORBA::ULong max); // uses max size
+  ExceptionDefSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ExceptionDef_ptr *buffer, 
+    CORBA::Boolean release=0
+  );
+  ExceptionDefSeq (const ExceptionDefSeq &); // copy ctor
+  ~ExceptionDefSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ExceptionDefSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ARRAYDEF___VAR_CH_)
-#define _CORBA_ARRAYDEF___VAR_CH_
+#if !defined (_IR_EXCEPTIONDEFSEQ___VAR_CH_)
+#define _IR_EXCEPTIONDEFSEQ___VAR_CH_
 
-  class TAO_Export CORBA_ArrayDef_var
-  {
-  public:
-    CORBA_ArrayDef_var (void); // default constructor
-    CORBA_ArrayDef_var (CORBA_ArrayDef_ptr);
-    CORBA_ArrayDef_var (const CORBA_ArrayDef_var &); // copy constructor
-    ~CORBA_ArrayDef_var (void); // destructor
+// *************************************************************
+// class IR::ExceptionDefSeq_var
+// *************************************************************
 
-    CORBA_ArrayDef_var &operator= (CORBA_ArrayDef_ptr);
-    CORBA_ArrayDef_var &operator= (const CORBA_ArrayDef_var &);
-    CORBA_ArrayDef_ptr operator-> (void) const;
+class TAO_Export ExceptionDefSeq_var
+{
+public:
+  ExceptionDefSeq_var (void); // default constructor
+  ExceptionDefSeq_var (ExceptionDefSeq *);
+  ExceptionDefSeq_var (const ExceptionDefSeq_var &); // copy constructor
+  ~ExceptionDefSeq_var (void); // destructor
+  
+  ExceptionDefSeq_var &operator= (ExceptionDefSeq *);
+  ExceptionDefSeq_var &operator= (const ExceptionDefSeq_var &);
+  ExceptionDefSeq *operator-> (void);
+  const ExceptionDefSeq *operator-> (void) const;
+  
+  operator const ExceptionDefSeq &() const;
+  operator ExceptionDefSeq &();
+  operator ExceptionDefSeq &() const;
+  operator ExceptionDefSeq *&(); // variable-size base types only
+  
+  TAO_Object_Manager<ExceptionDef, ExceptionDef_var> operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ExceptionDefSeq &in (void) const;
+  ExceptionDefSeq &inout (void);
+  ExceptionDefSeq *&out (void);
+  ExceptionDefSeq *_retn (void);
+  ExceptionDefSeq *ptr (void) const;
+
+private:
+  ExceptionDefSeq *ptr_;
+};
 
-    operator const CORBA_ArrayDef_ptr &() const;
-    operator CORBA_ArrayDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ArrayDef_ptr in (void) const;
-    CORBA_ArrayDef_ptr &inout (void);
-    CORBA_ArrayDef_ptr &out (void);
-    CORBA_ArrayDef_ptr _retn (void);
-    CORBA_ArrayDef_ptr ptr (void) const;
 
-  private:
-    CORBA_ArrayDef_ptr ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EXCEPTIONDEFSEQ___OUT_CH_)
+#define _IR_EXCEPTIONDEFSEQ___OUT_CH_
+
+class TAO_Export ExceptionDefSeq_out
+{
+public:
+  ExceptionDefSeq_out (ExceptionDefSeq *&);
+  ExceptionDefSeq_out (ExceptionDefSeq_var &);
+  ExceptionDefSeq_out (const ExceptionDefSeq_out &);
+  ExceptionDefSeq_out &operator= (const ExceptionDefSeq_out &);
+  ExceptionDefSeq_out &operator= (ExceptionDefSeq *);
+  operator ExceptionDefSeq *&();
+  ExceptionDefSeq *&ptr (void);
+  ExceptionDefSeq *operator-> (void);
+  TAO_Object_Manager<ExceptionDef, ExceptionDef_var> operator[] (CORBA::ULong index);
+  
+private:
+  ExceptionDefSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ExceptionDefSeq_var &);
+};
 
 
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDefSeq;
 
-#if !defined (_CORBA_ARRAYDEF___OUT_CH_)
-#define _CORBA_ARRAYDEF___OUT_CH_
 
-  class TAO_Export CORBA_ArrayDef_out
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_EXCDESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_EXCDESCRIPTIONSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_ArrayDef_out (CORBA_ArrayDef_ptr &);
-    CORBA_ArrayDef_out (CORBA_ArrayDef_var &);
-    CORBA_ArrayDef_out (const CORBA_ArrayDef_out &);
-    CORBA_ArrayDef_out &operator= (const CORBA_ArrayDef_out &);
-    CORBA_ArrayDef_out &operator= (const CORBA_ArrayDef_var &);
-    CORBA_ArrayDef_out &operator= (CORBA_ArrayDef_ptr);
-    operator CORBA_ArrayDef_ptr &();
-    CORBA_ArrayDef_ptr &ptr (void);
-    CORBA_ArrayDef_ptr operator-> (void);
-
-  private:
-    CORBA_ArrayDef_ptr &ptr_;
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      ExceptionDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (void); // Dtor.
+    // = Accessors.
+    ExceptionDescription &operator[] (CORBA::ULong i);
+    const ExceptionDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static ExceptionDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (ExceptionDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    ExceptionDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const ExceptionDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      ExceptionDescription *data,
+      CORBA::Boolean release);
   };
 
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EXCDESCRIPTIONSEQ_CH_)
+#define _IR_EXCDESCRIPTIONSEQ_CH_
+
+class ExcDescriptionSeq;
+class ExcDescriptionSeq_var;
+
+// *************************************************************
+// ExcDescriptionSeq
+// *************************************************************
+
+class TAO_Export ExcDescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<ExceptionDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ExcDescriptionSeq (void); // default ctor
+  ExcDescriptionSeq (CORBA::ULong max); // uses max size
+  ExcDescriptionSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ExceptionDescription *buffer, 
+    CORBA::Boolean release=0
+  );
+  ExcDescriptionSeq (const ExcDescriptionSeq &); // copy ctor
+  ~ExcDescriptionSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ExcDescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ARRAYDEF_CH_)
-#define _CORBA_ARRAYDEF_CH_
+#if !defined (_IR_EXCDESCRIPTIONSEQ___VAR_CH_)
+#define _IR_EXCDESCRIPTIONSEQ___VAR_CH_
 
-class TAO_Export CORBA_ArrayDef: public virtual CORBA_IDLType
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_ArrayDef_ptr _ptr_type;
-    typedef CORBA_ArrayDef_var _var_type;
-  #endif /* __GNUC__ */
+// *************************************************************
+// class IR::ExcDescriptionSeq_var
+// *************************************************************
 
-    // the static operations
-    static CORBA_ArrayDef_ptr _duplicate (CORBA_ArrayDef_ptr obj);
-    static CORBA_ArrayDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ArrayDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ArrayDef_ptr _nil (void)
-      {
-        return (CORBA::ArrayDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+class TAO_Export ExcDescriptionSeq_var
+{
+public:
+  ExcDescriptionSeq_var (void); // default constructor
+  ExcDescriptionSeq_var (ExcDescriptionSeq *);
+  ExcDescriptionSeq_var (const ExcDescriptionSeq_var &); // copy constructor
+  ~ExcDescriptionSeq_var (void); // destructor
+  
+  ExcDescriptionSeq_var &operator= (ExcDescriptionSeq *);
+  ExcDescriptionSeq_var &operator= (const ExcDescriptionSeq_var &);
+  ExcDescriptionSeq *operator-> (void);
+  const ExcDescriptionSeq *operator-> (void) const;
+  
+  operator const ExcDescriptionSeq &() const;
+  operator ExcDescriptionSeq &();
+  operator ExcDescriptionSeq &() const;
+  operator ExcDescriptionSeq *&(); // variable-size base types only
+  
+  ExceptionDescription &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ExcDescriptionSeq &in (void) const;
+  ExcDescriptionSeq &inout (void);
+  ExcDescriptionSeq *&out (void);
+  ExcDescriptionSeq *_retn (void);
+  ExcDescriptionSeq *ptr (void) const;
+
+private:
+  ExcDescriptionSeq *ptr_;
+};
 
-    virtual CORBA::ULong length (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual void length (
-        CORBA::ULong length,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA::TypeCode_ptr element_type (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_IDLType_ptr element_type_def (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_EXCDESCRIPTIONSEQ___OUT_CH_)
+#define _IR_EXCDESCRIPTIONSEQ___OUT_CH_
+
+class TAO_Export ExcDescriptionSeq_out
+{
+public:
+  ExcDescriptionSeq_out (ExcDescriptionSeq *&);
+  ExcDescriptionSeq_out (ExcDescriptionSeq_var &);
+  ExcDescriptionSeq_out (const ExcDescriptionSeq_out &);
+  ExcDescriptionSeq_out &operator= (const ExcDescriptionSeq_out &);
+  ExcDescriptionSeq_out &operator= (ExcDescriptionSeq *);
+  operator ExcDescriptionSeq *&();
+  ExcDescriptionSeq *&ptr (void);
+  ExcDescriptionSeq *operator-> (void);
+  ExceptionDescription &operator[] (CORBA::ULong index);
+  
+private:
+  ExcDescriptionSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ExcDescriptionSeq_var &);
+};
 
-    virtual void element_type_def (
-        CORBA_IDLType_ptr element_type_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExcDescriptionSeq;
+
+enum AttributeMode
+{
+    ATTR_NORMAL,
+    ATTR_READONLY,
+    AttributeMode_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF
+};
+typedef AttributeMode &AttributeMode_out;
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeMode;
 
-  protected:
-    CORBA_ArrayDef (void);
-    CORBA_ArrayDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_ArrayDef (void);
-  private:
-    CORBA_ArrayDef (const CORBA_ArrayDef &);
-    void operator= (const CORBA_ArrayDef &);
-  };
 
+#if !defined (_IR_ATTRIBUTEDEF___PTR_CH_)
+#define _IR_ATTRIBUTEDEF___PTR_CH_
+
+class AttributeDef;
+typedef AttributeDef *AttributeDef_ptr;
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_EXCEPTIONDEF___VAR_CH_)
-#define _CORBA_EXCEPTIONDEF___VAR_CH_
 
-  class TAO_Export CORBA_ExceptionDef_var
-  {
-  public:
-    CORBA_ExceptionDef_var (void); // default constructor
-    CORBA_ExceptionDef_var (CORBA_ExceptionDef_ptr);
-    CORBA_ExceptionDef_var (const CORBA_ExceptionDef_var &); // copy constructor
-    ~CORBA_ExceptionDef_var (void); // destructor
+#if !defined (_IR_ATTRIBUTEDEF___VAR_CH_)
+#define _IR_ATTRIBUTEDEF___VAR_CH_
+
+class TAO_Export AttributeDef_var
+{
+public:
+  AttributeDef_var (void); // default constructor
+  AttributeDef_var (AttributeDef_ptr);
+  AttributeDef_var (const AttributeDef_var &); // copy constructor
+  ~AttributeDef_var (void); // destructor
+  
+  AttributeDef_var &operator= (AttributeDef_ptr);
+  AttributeDef_var &operator= (const AttributeDef_var &);
+  AttributeDef_ptr operator-> (void) const;
+  
+  operator const AttributeDef_ptr &() const;
+  operator AttributeDef_ptr &();
+  // in, inout, out, _retn 
+  AttributeDef_ptr in (void) const;
+  AttributeDef_ptr &inout (void);
+  AttributeDef_ptr &out (void);
+  AttributeDef_ptr _retn (void);
+  AttributeDef_ptr ptr (void) const;
+
+private:
+  AttributeDef_ptr ptr_;
+};
 
-    CORBA_ExceptionDef_var &operator= (CORBA_ExceptionDef_ptr);
-    CORBA_ExceptionDef_var &operator= (const CORBA_ExceptionDef_var &);
-    CORBA_ExceptionDef_ptr operator-> (void) const;
 
-    operator const CORBA_ExceptionDef_ptr &() const;
-    operator CORBA_ExceptionDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ExceptionDef_ptr in (void) const;
-    CORBA_ExceptionDef_ptr &inout (void);
-    CORBA_ExceptionDef_ptr &out (void);
-    CORBA_ExceptionDef_ptr _retn (void);
-    CORBA_ExceptionDef_ptr ptr (void) const;
+#endif /* end #if !defined */
 
-  private:
-    CORBA_ExceptionDef_ptr ptr_;
-  };
+
+#if !defined (_IR_ATTRIBUTEDEF___OUT_CH_)
+#define _IR_ATTRIBUTEDEF___OUT_CH_
+
+class TAO_Export AttributeDef_out
+{
+public:
+  AttributeDef_out (AttributeDef_ptr &);
+  AttributeDef_out (AttributeDef_var &);
+  AttributeDef_out (const AttributeDef_out &);
+  AttributeDef_out &operator= (const AttributeDef_out &);
+  AttributeDef_out &operator= (const AttributeDef_var &);
+  AttributeDef_out &operator= (AttributeDef_ptr);
+  operator AttributeDef_ptr &();
+  AttributeDef_ptr &ptr (void);
+  AttributeDef_ptr operator-> (void);
+  
+private:
+  AttributeDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_EXCEPTIONDEF___OUT_CH_)
-#define _CORBA_EXCEPTIONDEF___OUT_CH_
+#if !defined (_IR_ATTRIBUTEDEF_CH_)
+#define _IR_ATTRIBUTEDEF_CH_
 
-  class TAO_Export CORBA_ExceptionDef_out
-  {
-  public:
-    CORBA_ExceptionDef_out (CORBA_ExceptionDef_ptr &);
-    CORBA_ExceptionDef_out (CORBA_ExceptionDef_var &);
-    CORBA_ExceptionDef_out (const CORBA_ExceptionDef_out &);
-    CORBA_ExceptionDef_out &operator= (const CORBA_ExceptionDef_out &);
-    CORBA_ExceptionDef_out &operator= (const CORBA_ExceptionDef_var &);
-    CORBA_ExceptionDef_out &operator= (CORBA_ExceptionDef_ptr);
-    operator CORBA_ExceptionDef_ptr &();
-    CORBA_ExceptionDef_ptr &ptr (void);
-    CORBA_ExceptionDef_ptr operator-> (void);
+class TAO_Export AttributeDef: public virtual Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef AttributeDef_ptr _ptr_type;
+  typedef AttributeDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  private:
-    CORBA_ExceptionDef_ptr &ptr_;
+  // the static operations
+  static AttributeDef_ptr _duplicate (AttributeDef_ptr obj);
+  static AttributeDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static AttributeDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static AttributeDef_ptr _nil (void)
+    {
+      return (AttributeDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      IR::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::AttributeMode mode (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void mode (
+      IR::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  AttributeDef (void);
+  AttributeDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~AttributeDef (void);
+private:
+  AttributeDef (const AttributeDef &);
+  void operator= (const AttributeDef &);
+};
+
+class TAO_IR_AttributeDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_AttributeDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_AttributeDef_Default_Proxy_Factory (void);
+  
+  virtual AttributeDef_ptr create_proxy (
+      AttributeDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_AttributeDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_AttributeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_AttributeDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  AttributeDef_ptr create_proxy (
+      AttributeDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_AttributeDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_AttributeDef_Proxy_Factory_Adapter (void);
+  TAO_IR_AttributeDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_AttributeDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_AttributeDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
+  typedef ACE_Singleton<TAO_IR_AttributeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_AttributeDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_AttributeDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, AttributeDef)
+  {
+  public:
+    TAO_IR_AttributeDef_Smart_Proxy_Base (::IR::AttributeDef_ptr proxy);
+    ~TAO_IR_AttributeDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      IR::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::AttributeMode mode (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void mode (
+      IR::AttributeMode mode,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::AttributeDef_var base_proxy_;
+};
+
 
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDef;
+
+struct AttributeDescription;
+class AttributeDescription_var;
+
+struct TAO_Export AttributeDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef AttributeDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+  ACE_NESTED_CLASS (IR, AttributeMode) mode;
+  ACE_NESTED_CLASS (IR, ExcDescriptionSeq) get_exceptions;
+  ACE_NESTED_CLASS (IR, ExcDescriptionSeq) put_exceptions;
+};
+
+class TAO_Export AttributeDescription_var
+{
+public:
+  AttributeDescription_var (void); // default constructor
+  AttributeDescription_var (AttributeDescription *);
+  AttributeDescription_var (const AttributeDescription_var &); // copy constructor
+  ~AttributeDescription_var (void); // destructor
+  
+  AttributeDescription_var &operator= (AttributeDescription *);
+  AttributeDescription_var &operator= (const AttributeDescription_var &);
+  AttributeDescription *operator-> (void);
+  const AttributeDescription *operator-> (void) const;
+  
+  operator const AttributeDescription &() const;
+  operator AttributeDescription &();
+  operator AttributeDescription &() const;
+  operator AttributeDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const AttributeDescription &in (void) const;
+  AttributeDescription &inout (void);
+  AttributeDescription *&out (void);
+  AttributeDescription *_retn (void);
+  AttributeDescription *ptr (void) const;
+
+private:
+  AttributeDescription *ptr_;
+};
+
+class TAO_Export AttributeDescription_out
+{
+public:
+  AttributeDescription_out (AttributeDescription *&);
+  AttributeDescription_out (AttributeDescription_var &);
+  AttributeDescription_out (const AttributeDescription_out &);
+  AttributeDescription_out &operator= (const AttributeDescription_out &);
+  AttributeDescription_out &operator= (AttributeDescription *);
+  operator AttributeDescription *&();
+  AttributeDescription *&ptr (void);
+  AttributeDescription *operator-> (void);
+  
+private:
+  AttributeDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const AttributeDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDescription;
+
+enum OperationMode
+{
+    OP_NORMAL,
+    OP_ONEWAY,
+    OperationMode_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF
+};
+typedef OperationMode &OperationMode_out;
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationMode;
+
+enum ParameterMode
+{
+    PARAM_IN,
+    PARAM_OUT,
+    PARAM_INOUT,
+    ParameterMode_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF
+};
+typedef ParameterMode &ParameterMode_out;
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterMode;
+
+struct ParameterDescription;
+class ParameterDescription_var;
+
+struct TAO_Export ParameterDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ParameterDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  CORBA::TypeCode_var type;
+  TAO_Object_Field_T<ACE_NESTED_CLASS (IR, IDLType), ACE_NESTED_CLASS (IR, IDLType_var)> type_def;
+  ACE_NESTED_CLASS (IR, ParameterMode) mode;
+};
+
+class TAO_Export ParameterDescription_var
+{
+public:
+  ParameterDescription_var (void); // default constructor
+  ParameterDescription_var (ParameterDescription *);
+  ParameterDescription_var (const ParameterDescription_var &); // copy constructor
+  ~ParameterDescription_var (void); // destructor
+  
+  ParameterDescription_var &operator= (ParameterDescription *);
+  ParameterDescription_var &operator= (const ParameterDescription_var &);
+  ParameterDescription *operator-> (void);
+  const ParameterDescription *operator-> (void) const;
+  
+  operator const ParameterDescription &() const;
+  operator ParameterDescription &();
+  operator ParameterDescription &() const;
+  operator ParameterDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const ParameterDescription &in (void) const;
+  ParameterDescription &inout (void);
+  ParameterDescription *&out (void);
+  ParameterDescription *_retn (void);
+  ParameterDescription *ptr (void) const;
+
+private:
+  ParameterDescription *ptr_;
+};
+
+class TAO_Export ParameterDescription_out
+{
+public:
+  ParameterDescription_out (ParameterDescription *&);
+  ParameterDescription_out (ParameterDescription_var &);
+  ParameterDescription_out (const ParameterDescription_out &);
+  ParameterDescription_out &operator= (const ParameterDescription_out &);
+  ParameterDescription_out &operator= (ParameterDescription *);
+  operator ParameterDescription *&();
+  ParameterDescription *&ptr (void);
+  ParameterDescription *operator-> (void);
+  
+private:
+  ParameterDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ParameterDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterDescription;
+
 
-#if !defined (_CORBA_EXCEPTIONDEF_CH_)
-#define _CORBA_EXCEPTIONDEF_CH_
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_PARDESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_PARDESCRIPTIONSEQ_CH_
 
-class TAO_Export CORBA_ExceptionDef: public virtual CORBA_Contained, public virtual CORBA_Container
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ParDescriptionSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_ExceptionDef_ptr _ptr_type;
-    typedef CORBA_ExceptionDef_var _var_type;
-  #endif /* __GNUC__ */
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      ParameterDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq (const _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (void); // Dtor.
+    // = Accessors.
+    ParameterDescription &operator[] (CORBA::ULong i);
+    const ParameterDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static ParameterDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (ParameterDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    ParameterDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const ParameterDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      ParameterDescription *data,
+      CORBA::Boolean release);
+  };
 
-    // the static operations
-    static CORBA_ExceptionDef_ptr _duplicate (CORBA_ExceptionDef_ptr obj);
-    static CORBA_ExceptionDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ExceptionDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ExceptionDef_ptr _nil (void)
-      {
-        return (CORBA::ExceptionDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+#endif /* end #if !defined */
 
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_StructMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-    virtual void members (
-        const CORBA_StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_PARDESCRIPTIONSEQ_CH_)
+#define _IR_PARDESCRIPTIONSEQ_CH_
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+class ParDescriptionSeq;
+class ParDescriptionSeq_var;
 
-  protected:
-    CORBA_ExceptionDef (void);
-    CORBA_ExceptionDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_ExceptionDef (void);
-  private:
-    CORBA_ExceptionDef (const CORBA_ExceptionDef &);
-    void operator= (const CORBA_ExceptionDef &);
-  };
+// *************************************************************
+// ParDescriptionSeq
+// *************************************************************
 
+class TAO_Export ParDescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ParDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<ParameterDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ParDescriptionSeq (void); // default ctor
+  ParDescriptionSeq (CORBA::ULong max); // uses max size
+  ParDescriptionSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ParameterDescription *buffer, 
+    CORBA::Boolean release=0
+  );
+  ParDescriptionSeq (const ParDescriptionSeq &); // copy ctor
+  ~ParDescriptionSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ParDescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
 
 #endif /* end #if !defined */
 
-  struct  CORBA_ExceptionDescription
-  {
-    static void _tao_any_destructor (void*);
 
-    TAO_String_Manager name;
-    TAO_String_Manager id;
-    TAO_String_Manager defined_in;
-    TAO_String_Manager version;
-    CORBA::TypeCode_var type;
-  };
+#if !defined (_IR_PARDESCRIPTIONSEQ___VAR_CH_)
+#define _IR_PARDESCRIPTIONSEQ___VAR_CH_
 
-  class TAO_Export CORBA_ExceptionDescription_var
-  {
-  public:
-    CORBA_ExceptionDescription_var (void); // default constructor
-    CORBA_ExceptionDescription_var (CORBA_ExceptionDescription *);
-    CORBA_ExceptionDescription_var (const CORBA_ExceptionDescription_var &); // copy constructor
-    ~CORBA_ExceptionDescription_var (void); // destructor
-
-    CORBA_ExceptionDescription_var &operator= (CORBA_ExceptionDescription *);
-    CORBA_ExceptionDescription_var &operator= (const CORBA_ExceptionDescription_var &);
-    CORBA_ExceptionDescription *operator-> (void);
-    const CORBA_ExceptionDescription *operator-> (void) const;
-
-    operator const CORBA_ExceptionDescription &() const;
-    operator CORBA_ExceptionDescription &();
-    operator CORBA_ExceptionDescription &() const;
-    // in, inout, out, _retn
-    const CORBA_ExceptionDescription &in (void) const;
-    CORBA_ExceptionDescription &inout (void);
-    CORBA_ExceptionDescription *&out (void);
-    CORBA_ExceptionDescription *_retn (void);
-    CORBA_ExceptionDescription *ptr (void) const;
+// *************************************************************
+// class IR::ParDescriptionSeq_var
+// *************************************************************
 
-  private:
-    CORBA_ExceptionDescription *ptr_;
-  };
+class TAO_Export ParDescriptionSeq_var
+{
+public:
+  ParDescriptionSeq_var (void); // default constructor
+  ParDescriptionSeq_var (ParDescriptionSeq *);
+  ParDescriptionSeq_var (const ParDescriptionSeq_var &); // copy constructor
+  ~ParDescriptionSeq_var (void); // destructor
+  
+  ParDescriptionSeq_var &operator= (ParDescriptionSeq *);
+  ParDescriptionSeq_var &operator= (const ParDescriptionSeq_var &);
+  ParDescriptionSeq *operator-> (void);
+  const ParDescriptionSeq *operator-> (void) const;
+  
+  operator const ParDescriptionSeq &() const;
+  operator ParDescriptionSeq &();
+  operator ParDescriptionSeq &() const;
+  operator ParDescriptionSeq *&(); // variable-size base types only
+  
+  ParameterDescription &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ParDescriptionSeq &in (void) const;
+  ParDescriptionSeq &inout (void);
+  ParDescriptionSeq *&out (void);
+  ParDescriptionSeq *_retn (void);
+  ParDescriptionSeq *ptr (void) const;
+
+private:
+  ParDescriptionSeq *ptr_;
+};
 
-  class TAO_Export CORBA_ExceptionDescription_out
-  {
-  public:
-    CORBA_ExceptionDescription_out (CORBA_ExceptionDescription *&);
-    CORBA_ExceptionDescription_out (CORBA_ExceptionDescription_var &);
-    CORBA_ExceptionDescription_out (const CORBA_ExceptionDescription_out &);
-    CORBA_ExceptionDescription_out &operator= (const CORBA_ExceptionDescription_out &);
-    CORBA_ExceptionDescription_out &operator= (CORBA_ExceptionDescription *);
-    operator CORBA_ExceptionDescription *&();
-    CORBA_ExceptionDescription *&ptr (void);
-    CORBA_ExceptionDescription *operator-> (void);
 
-  private:
-    CORBA_ExceptionDescription *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ExceptionDescription_var &);
-  };
+#endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ATTRIBUTEDEF___VAR_CH_)
-#define _CORBA_ATTRIBUTEDEF___VAR_CH_
+#if !defined (_IR_PARDESCRIPTIONSEQ___OUT_CH_)
+#define _IR_PARDESCRIPTIONSEQ___OUT_CH_
+
+class TAO_Export ParDescriptionSeq_out
+{
+public:
+  ParDescriptionSeq_out (ParDescriptionSeq *&);
+  ParDescriptionSeq_out (ParDescriptionSeq_var &);
+  ParDescriptionSeq_out (const ParDescriptionSeq_out &);
+  ParDescriptionSeq_out &operator= (const ParDescriptionSeq_out &);
+  ParDescriptionSeq_out &operator= (ParDescriptionSeq *);
+  operator ParDescriptionSeq *&();
+  ParDescriptionSeq *&ptr (void);
+  ParDescriptionSeq *operator-> (void);
+  ParameterDescription &operator[] (CORBA::ULong index);
+  
+private:
+  ParDescriptionSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ParDescriptionSeq_var &);
+};
 
-  class TAO_Export CORBA_AttributeDef_var
-  {
-  public:
-    CORBA_AttributeDef_var (void); // default constructor
-    CORBA_AttributeDef_var (CORBA_AttributeDef_ptr);
-    CORBA_AttributeDef_var (const CORBA_AttributeDef_var &); // copy constructor
-    ~CORBA_AttributeDef_var (void); // destructor
 
-    CORBA_AttributeDef_var &operator= (CORBA_AttributeDef_ptr);
-    CORBA_AttributeDef_var &operator= (const CORBA_AttributeDef_var &);
-    CORBA_AttributeDef_ptr operator-> (void) const;
+#endif /* end #if !defined */
 
-    operator const CORBA_AttributeDef_ptr &() const;
-    operator CORBA_AttributeDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_AttributeDef_ptr in (void) const;
-    CORBA_AttributeDef_ptr &inout (void);
-    CORBA_AttributeDef_ptr &out (void);
-    CORBA_AttributeDef_ptr _retn (void);
-    CORBA_AttributeDef_ptr ptr (void) const;
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParDescriptionSeq;
 
-  private:
-    CORBA_AttributeDef_ptr ptr_;
-  };
+typedef char * ContextIdentifier;
+typedef CORBA::String_var ContextIdentifier_var;
+typedef CORBA::String_out ContextIdentifier_out;
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdentifier;
+
+
+#if !defined (_IR_CONTEXTIDSEQ_CH_)
+#define _IR_CONTEXTIDSEQ_CH_
 
+class ContextIdSeq;
+class ContextIdSeq_var;
+
+// *************************************************************
+// ContextIdSeq
+// *************************************************************
+
+class TAO_Export ContextIdSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ContextIdSeq (void); // default ctor
+  ContextIdSeq (CORBA::ULong max); // uses max size
+  ContextIdSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    char * *buffer, 
+    CORBA::Boolean release=0
+  );
+  ContextIdSeq (const ContextIdSeq &); // copy ctor
+  ~ContextIdSeq (void);
+  static void _tao_any_destructor (void*);
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ContextIdSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ATTRIBUTEDEF___OUT_CH_)
-#define _CORBA_ATTRIBUTEDEF___OUT_CH_
+#if !defined (_IR_CONTEXTIDSEQ___VAR_CH_)
+#define _IR_CONTEXTIDSEQ___VAR_CH_
 
-  class TAO_Export CORBA_AttributeDef_out
-  {
-  public:
-    CORBA_AttributeDef_out (CORBA_AttributeDef_ptr &);
-    CORBA_AttributeDef_out (CORBA_AttributeDef_var &);
-    CORBA_AttributeDef_out (const CORBA_AttributeDef_out &);
-    CORBA_AttributeDef_out &operator= (const CORBA_AttributeDef_out &);
-    CORBA_AttributeDef_out &operator= (const CORBA_AttributeDef_var &);
-    CORBA_AttributeDef_out &operator= (CORBA_AttributeDef_ptr);
-    operator CORBA_AttributeDef_ptr &();
-    CORBA_AttributeDef_ptr &ptr (void);
-    CORBA_AttributeDef_ptr operator-> (void);
+// *************************************************************
+// class IR::ContextIdSeq_var
+// *************************************************************
 
-  private:
-    CORBA_AttributeDef_ptr &ptr_;
-  };
+class TAO_Export ContextIdSeq_var
+{
+public:
+  ContextIdSeq_var (void); // default constructor
+  ContextIdSeq_var (ContextIdSeq *);
+  ContextIdSeq_var (const ContextIdSeq_var &); // copy constructor
+  ~ContextIdSeq_var (void); // destructor
+  
+  ContextIdSeq_var &operator= (ContextIdSeq *);
+  ContextIdSeq_var &operator= (const ContextIdSeq_var &);
+  ContextIdSeq *operator-> (void);
+  const ContextIdSeq *operator-> (void) const;
+  
+  operator const ContextIdSeq &() const;
+  operator ContextIdSeq &();
+  operator ContextIdSeq &() const;
+  operator ContextIdSeq *&(); // variable-size base types only
+  
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ContextIdSeq &in (void) const;
+  ContextIdSeq &inout (void);
+  ContextIdSeq *&out (void);
+  ContextIdSeq *_retn (void);
+  ContextIdSeq *ptr (void) const;
+
+private:
+  ContextIdSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ATTRIBUTEDEF_CH_)
-#define _CORBA_ATTRIBUTEDEF_CH_
+#if !defined (_IR_CONTEXTIDSEQ___OUT_CH_)
+#define _IR_CONTEXTIDSEQ___OUT_CH_
+
+class TAO_Export ContextIdSeq_out
+{
+public:
+  ContextIdSeq_out (ContextIdSeq *&);
+  ContextIdSeq_out (ContextIdSeq_var &);
+  ContextIdSeq_out (const ContextIdSeq_out &);
+  ContextIdSeq_out &operator= (const ContextIdSeq_out &);
+  ContextIdSeq_out &operator= (ContextIdSeq *);
+  operator ContextIdSeq *&();
+  ContextIdSeq *&ptr (void);
+  ContextIdSeq *operator-> (void);
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  
+private:
+  ContextIdSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ContextIdSeq_var &);
+};
 
-class TAO_Export CORBA_AttributeDef: public virtual CORBA_Contained
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_AttributeDef_ptr _ptr_type;
-    typedef CORBA_AttributeDef_var _var_type;
-  #endif /* __GNUC__ */
 
-    // the static operations
-    static CORBA_AttributeDef_ptr _duplicate (CORBA_AttributeDef_ptr obj);
-    static CORBA_AttributeDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_AttributeDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_AttributeDef_ptr _nil (void)
-      {
-        return (CORBA::AttributeDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+#endif /* end #if !defined */
 
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdSeq;
 
-    virtual CORBA_IDLType_ptr type_def (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual void type_def (
-        CORBA_IDLType_ptr type_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_OPERATIONDEF___PTR_CH_)
+#define _IR_OPERATIONDEF___PTR_CH_
 
-    virtual CORBA::AttributeMode mode (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+class OperationDef;
+typedef OperationDef *OperationDef_ptr;
 
-    virtual void mode (
-        CORBA::AttributeMode mode,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
 
-  protected:
-    CORBA_AttributeDef (void);
-    CORBA_AttributeDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_AttributeDef (void);
-  private:
-    CORBA_AttributeDef (const CORBA_AttributeDef &);
-    void operator= (const CORBA_AttributeDef &);
-  };
+#if !defined (_IR_OPERATIONDEF___VAR_CH_)
+#define _IR_OPERATIONDEF___VAR_CH_
+
+class TAO_Export OperationDef_var
+{
+public:
+  OperationDef_var (void); // default constructor
+  OperationDef_var (OperationDef_ptr);
+  OperationDef_var (const OperationDef_var &); // copy constructor
+  ~OperationDef_var (void); // destructor
+  
+  OperationDef_var &operator= (OperationDef_ptr);
+  OperationDef_var &operator= (const OperationDef_var &);
+  OperationDef_ptr operator-> (void) const;
+  
+  operator const OperationDef_ptr &() const;
+  operator OperationDef_ptr &();
+  // in, inout, out, _retn 
+  OperationDef_ptr in (void) const;
+  OperationDef_ptr &inout (void);
+  OperationDef_ptr &out (void);
+  OperationDef_ptr _retn (void);
+  OperationDef_ptr ptr (void) const;
+
+private:
+  OperationDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-  struct  CORBA_AttributeDescription
-  {
-    static void _tao_any_destructor (void*);
 
-    TAO_String_Manager name;
-    TAO_String_Manager id;
-    TAO_String_Manager defined_in;
-    TAO_String_Manager version;
-    CORBA::TypeCode_var type;
-    CORBA::AttributeMode mode;
-  };
+#if !defined (_IR_OPERATIONDEF___OUT_CH_)
+#define _IR_OPERATIONDEF___OUT_CH_
 
-  class TAO_Export CORBA_AttributeDescription_var
-  {
-  public:
-    CORBA_AttributeDescription_var (void); // default constructor
-    CORBA_AttributeDescription_var (CORBA_AttributeDescription *);
-    CORBA_AttributeDescription_var (const CORBA_AttributeDescription_var &); // copy constructor
-    ~CORBA_AttributeDescription_var (void); // destructor
-
-    CORBA_AttributeDescription_var &operator= (CORBA_AttributeDescription *);
-    CORBA_AttributeDescription_var &operator= (const CORBA_AttributeDescription_var &);
-    CORBA_AttributeDescription *operator-> (void);
-    const CORBA_AttributeDescription *operator-> (void) const;
-
-    operator const CORBA_AttributeDescription &() const;
-    operator CORBA_AttributeDescription &();
-    operator CORBA_AttributeDescription &() const;
-    // in, inout, out, _retn
-    const CORBA_AttributeDescription &in (void) const;
-    CORBA_AttributeDescription &inout (void);
-    CORBA_AttributeDescription *&out (void);
-    CORBA_AttributeDescription *_retn (void);
-    CORBA_AttributeDescription *ptr (void) const;
+class TAO_Export OperationDef_out
+{
+public:
+  OperationDef_out (OperationDef_ptr &);
+  OperationDef_out (OperationDef_var &);
+  OperationDef_out (const OperationDef_out &);
+  OperationDef_out &operator= (const OperationDef_out &);
+  OperationDef_out &operator= (const OperationDef_var &);
+  OperationDef_out &operator= (OperationDef_ptr);
+  operator OperationDef_ptr &();
+  OperationDef_ptr &ptr (void);
+  OperationDef_ptr operator-> (void);
+  
+private:
+  OperationDef_ptr &ptr_;
+};
 
-  private:
-    CORBA_AttributeDescription *ptr_;
-  };
 
-  class TAO_Export CORBA_AttributeDescription_out
-  {
-  public:
-    CORBA_AttributeDescription_out (CORBA_AttributeDescription *&);
-    CORBA_AttributeDescription_out (CORBA_AttributeDescription_var &);
-    CORBA_AttributeDescription_out (const CORBA_AttributeDescription_out &);
-    CORBA_AttributeDescription_out &operator= (const CORBA_AttributeDescription_out &);
-    CORBA_AttributeDescription_out &operator= (CORBA_AttributeDescription *);
-    operator CORBA_AttributeDescription *&();
-    CORBA_AttributeDescription *&ptr (void);
-    CORBA_AttributeDescription *operator-> (void);
+#endif /* end #if !defined */
 
-  private:
-    CORBA_AttributeDescription *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_AttributeDescription_var &);
-  };
 
-  struct  CORBA_ParameterDescription
-  {
-    static void _tao_any_destructor (void*);
+#if !defined (_IR_OPERATIONDEF_CH_)
+#define _IR_OPERATIONDEF_CH_
 
-    TAO_String_Manager name;
-    CORBA::TypeCode_var type;
-    TAO_Object_Field_T<CORBA_IDLType,CORBA_IDLType_var> type_def;
-    CORBA::ParameterMode mode;
-  };
+class TAO_Export OperationDef: public virtual Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef OperationDef_ptr _ptr_type;
+  typedef OperationDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  class TAO_Export CORBA_ParameterDescription_var
-  {
-  public:
-    CORBA_ParameterDescription_var (void); // default constructor
-    CORBA_ParameterDescription_var (CORBA_ParameterDescription *);
-    CORBA_ParameterDescription_var (const CORBA_ParameterDescription_var &); // copy constructor
-    ~CORBA_ParameterDescription_var (void); // destructor
-
-    CORBA_ParameterDescription_var &operator= (CORBA_ParameterDescription *);
-    CORBA_ParameterDescription_var &operator= (const CORBA_ParameterDescription_var &);
-    CORBA_ParameterDescription *operator-> (void);
-    const CORBA_ParameterDescription *operator-> (void) const;
-
-    operator const CORBA_ParameterDescription &() const;
-    operator CORBA_ParameterDescription &();
-    operator CORBA_ParameterDescription &() const;
-    // in, inout, out, _retn
-    const CORBA_ParameterDescription &in (void) const;
-    CORBA_ParameterDescription &inout (void);
-    CORBA_ParameterDescription *&out (void);
-    CORBA_ParameterDescription *_retn (void);
-    CORBA_ParameterDescription *ptr (void) const;
+  // the static operations
+  static OperationDef_ptr _duplicate (OperationDef_ptr obj);
+  static OperationDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static OperationDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static OperationDef_ptr _nil (void)
+    {
+      return (OperationDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr result (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr result_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void result_def (
+      IR::IDLType_ptr result_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ParDescriptionSeq * params (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void params (
+      const IR::ParDescriptionSeq & params,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::OperationMode mode (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void mode (
+      IR::OperationMode mode,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ContextIdSeq * contexts (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void contexts (
+      const IR::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ExceptionDefSeq * exceptions (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void exceptions (
+      const IR::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
 
-  private:
-    CORBA_ParameterDescription *ptr_;
+protected:
+  OperationDef (void);
+  OperationDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~OperationDef (void);
+private:
+  OperationDef (const OperationDef &);
+  void operator= (const OperationDef &);
+};
+
+class TAO_IR_OperationDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_OperationDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_OperationDef_Default_Proxy_Factory (void);
+  
+  virtual OperationDef_ptr create_proxy (
+      OperationDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_OperationDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_OperationDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_OperationDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  OperationDef_ptr create_proxy (
+      OperationDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_OperationDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_OperationDef_Proxy_Factory_Adapter (void);
+  TAO_IR_OperationDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_OperationDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_OperationDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
-  class TAO_Export CORBA_ParameterDescription_out
+  typedef ACE_Singleton<TAO_IR_OperationDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_OperationDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_OperationDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, OperationDef)
   {
   public:
-    CORBA_ParameterDescription_out (CORBA_ParameterDescription *&);
-    CORBA_ParameterDescription_out (CORBA_ParameterDescription_var &);
-    CORBA_ParameterDescription_out (const CORBA_ParameterDescription_out &);
-    CORBA_ParameterDescription_out &operator= (const CORBA_ParameterDescription_out &);
-    CORBA_ParameterDescription_out &operator= (CORBA_ParameterDescription *);
-    operator CORBA_ParameterDescription *&();
-    CORBA_ParameterDescription *&ptr (void);
-    CORBA_ParameterDescription *operator-> (void);
+    TAO_IR_OperationDef_Smart_Proxy_Base (::IR::OperationDef_ptr proxy);
+    ~TAO_IR_OperationDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::TypeCode_ptr result (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr result_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void result_def (
+      IR::IDLType_ptr result_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ParDescriptionSeq * params (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void params (
+      const IR::ParDescriptionSeq & params,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::OperationMode mode (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void mode (
+      IR::OperationMode mode,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ContextIdSeq * contexts (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void contexts (
+      const IR::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ExceptionDefSeq * exceptions (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void exceptions (
+      const IR::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::OperationDef_var base_proxy_;
+};
 
-  private:
-    CORBA_ParameterDescription *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ParameterDescription_var &);
-  };
 
+#endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDef;
+
+struct OperationDescription;
+class OperationDescription_var;
+
+struct TAO_Export OperationDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef OperationDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var result;
+  ACE_NESTED_CLASS (IR, OperationMode) mode;
+  ACE_NESTED_CLASS (IR, ContextIdSeq) contexts;
+  ACE_NESTED_CLASS (IR, ParDescriptionSeq) parameters;
+  ACE_NESTED_CLASS (IR, ExcDescriptionSeq) exceptions;
+};
+
+class TAO_Export OperationDescription_var
+{
+public:
+  OperationDescription_var (void); // default constructor
+  OperationDescription_var (OperationDescription *);
+  OperationDescription_var (const OperationDescription_var &); // copy constructor
+  ~OperationDescription_var (void); // destructor
+  
+  OperationDescription_var &operator= (OperationDescription *);
+  OperationDescription_var &operator= (const OperationDescription_var &);
+  OperationDescription *operator-> (void);
+  const OperationDescription *operator-> (void) const;
+  
+  operator const OperationDescription &() const;
+  operator OperationDescription &();
+  operator OperationDescription &() const;
+  operator OperationDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const OperationDescription &in (void) const;
+  OperationDescription &inout (void);
+  OperationDescription *&out (void);
+  OperationDescription *_retn (void);
+  OperationDescription *ptr (void) const;
+
+private:
+  OperationDescription *ptr_;
+};
+
+class TAO_Export OperationDescription_out
+{
+public:
+  OperationDescription_out (OperationDescription *&);
+  OperationDescription_out (OperationDescription_var &);
+  OperationDescription_out (const OperationDescription_out &);
+  OperationDescription_out &operator= (const OperationDescription_out &);
+  OperationDescription_out &operator= (OperationDescription *);
+  operator OperationDescription *&();
+  OperationDescription *&ptr (void);
+  OperationDescription *operator-> (void);
+  
+private:
+  OperationDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const OperationDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDescription;
+
+
+#if !defined (_IR_REPOSITORYIDSEQ_CH_)
+#define _IR_REPOSITORYIDSEQ_CH_
+
+class RepositoryIdSeq;
+class RepositoryIdSeq_var;
+
+// *************************************************************
+// RepositoryIdSeq
+// *************************************************************
+
+class TAO_Export RepositoryIdSeq : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  TAO_Unbounded_String_Sequence
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_String_Sequence
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  RepositoryIdSeq (void); // default ctor
+  RepositoryIdSeq (CORBA::ULong max); // uses max size
+  RepositoryIdSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    char * *buffer, 
+    CORBA::Boolean release=0
+  );
+  RepositoryIdSeq (const RepositoryIdSeq &); // copy ctor
+  ~RepositoryIdSeq (void);
+  static void _tao_any_destructor (void*);
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CH_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CH_
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef RepositoryIdSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+};
 
-      _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void); // Default constructor.
-      _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_ParameterDescription *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs);
-      _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs);
-      virtual ~_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void); // Dtor.
-      // = Accessors.
-      CORBA_ParameterDescription &operator[] (CORBA::ULong i);
-      const CORBA_ParameterDescription &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static CORBA_ParameterDescription *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA_ParameterDescription *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_REPOSITORYIDSEQ___VAR_CH_)
+#define _IR_REPOSITORYIDSEQ___VAR_CH_
+
+// *************************************************************
+// class IR::RepositoryIdSeq_var
+// *************************************************************
+
+class TAO_Export RepositoryIdSeq_var
+{
+public:
+  RepositoryIdSeq_var (void); // default constructor
+  RepositoryIdSeq_var (RepositoryIdSeq *);
+  RepositoryIdSeq_var (const RepositoryIdSeq_var &); // copy constructor
+  ~RepositoryIdSeq_var (void); // destructor
+  
+  RepositoryIdSeq_var &operator= (RepositoryIdSeq *);
+  RepositoryIdSeq_var &operator= (const RepositoryIdSeq_var &);
+  RepositoryIdSeq *operator-> (void);
+  const RepositoryIdSeq *operator-> (void) const;
+  
+  operator const RepositoryIdSeq &() const;
+  operator RepositoryIdSeq &();
+  operator RepositoryIdSeq &() const;
+  operator RepositoryIdSeq *&(); // variable-size base types only
+  
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const RepositoryIdSeq &in (void) const;
+  RepositoryIdSeq &inout (void);
+  RepositoryIdSeq *&out (void);
+  RepositoryIdSeq *_retn (void);
+  RepositoryIdSeq *ptr (void) const;
+
+private:
+  RepositoryIdSeq *ptr_;
+};
 
-      CORBA_ParameterDescription *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_ParameterDescription *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        CORBA_ParameterDescription *data,
-        CORBA::Boolean release);
-    };
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_REPOSITORYIDSEQ___OUT_CH_)
+#define _IR_REPOSITORYIDSEQ___OUT_CH_
+
+class TAO_Export RepositoryIdSeq_out
+{
+public:
+  RepositoryIdSeq_out (RepositoryIdSeq *&);
+  RepositoryIdSeq_out (RepositoryIdSeq_var &);
+  RepositoryIdSeq_out (const RepositoryIdSeq_out &);
+  RepositoryIdSeq_out &operator= (const RepositoryIdSeq_out &);
+  RepositoryIdSeq_out &operator= (RepositoryIdSeq *);
+  operator RepositoryIdSeq *&();
+  RepositoryIdSeq *&ptr (void);
+  RepositoryIdSeq *operator-> (void);
+  TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+  
+private:
+  RepositoryIdSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const RepositoryIdSeq_var &);
+};
 
-#if !defined (_CORBA_PARDESCRIPTIONSEQ_CH_)
-#define _CORBA_PARDESCRIPTIONSEQ_CH_
 
-  // *************************************************************
-  // ParDescriptionSeq
-  // *************************************************************
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RepositoryIdSeq;
+
 
-  class TAO_Export CORBA_ParDescriptionSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA_ParameterDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_OPDESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_OPDESCRIPTIONSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_OpDescriptionSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_ParDescriptionSeq (void); // default ctor
-    CORBA_ParDescriptionSeq (CORBA::ULong max); // uses max size
-    CORBA_ParDescriptionSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      CORBA_ParameterDescription *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_ParDescriptionSeq (const CORBA_ParDescriptionSeq &); // copy ctor
-    ~CORBA_ParDescriptionSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      OperationDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq (const _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (void); // Dtor.
+    // = Accessors.
+    OperationDescription &operator[] (CORBA::ULong i);
+    const OperationDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static OperationDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (OperationDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    OperationDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const OperationDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      OperationDescription *data,
+      CORBA::Boolean release);
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_PARDESCRIPTIONSEQ___VAR_CH_)
-#define _CORBA_PARDESCRIPTIONSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_OPDESCRIPTIONSEQ_CH_)
+#define _IR_OPDESCRIPTIONSEQ_CH_
+
+class OpDescriptionSeq;
+class OpDescriptionSeq_var;
 
 // *************************************************************
-  // class CORBA::ParDescriptionSeq_var
-  // *************************************************************
+// OpDescriptionSeq
+// *************************************************************
 
-  class TAO_Export CORBA_ParDescriptionSeq_var
-  {
-  public:
-    CORBA_ParDescriptionSeq_var (void); // default constructor
-    CORBA_ParDescriptionSeq_var (CORBA_ParDescriptionSeq *);
-    CORBA_ParDescriptionSeq_var (const CORBA_ParDescriptionSeq_var &); // copy constructor
-    ~CORBA_ParDescriptionSeq_var (void); // destructor
-
-    CORBA_ParDescriptionSeq_var &operator= (CORBA_ParDescriptionSeq *);
-    CORBA_ParDescriptionSeq_var &operator= (const CORBA_ParDescriptionSeq_var &);
-    CORBA_ParDescriptionSeq *operator-> (void);
-    const CORBA_ParDescriptionSeq *operator-> (void) const;
-
-    operator const CORBA_ParDescriptionSeq &() const;
-    operator CORBA_ParDescriptionSeq &();
-    operator CORBA_ParDescriptionSeq &() const;
-    CORBA_ParameterDescription &operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_ParDescriptionSeq &in (void) const;
-    CORBA_ParDescriptionSeq &inout (void);
-    CORBA_ParDescriptionSeq *&out (void);
-    CORBA_ParDescriptionSeq *_retn (void);
-    CORBA_ParDescriptionSeq *ptr (void) const;
+class TAO_Export OpDescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_OpDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<OperationDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  OpDescriptionSeq (void); // default ctor
+  OpDescriptionSeq (CORBA::ULong max); // uses max size
+  OpDescriptionSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    OperationDescription *buffer, 
+    CORBA::Boolean release=0
+  );
+  OpDescriptionSeq (const OpDescriptionSeq &); // copy ctor
+  ~OpDescriptionSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_ParDescriptionSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef OpDescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_PARDESCRIPTIONSEQ___OUT_CH_)
-#define _CORBA_PARDESCRIPTIONSEQ___OUT_CH_
+#if !defined (_IR_OPDESCRIPTIONSEQ___VAR_CH_)
+#define _IR_OPDESCRIPTIONSEQ___VAR_CH_
 
-  class TAO_Export CORBA_ParDescriptionSeq_out
-  {
-  public:
-    CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSeq *&);
-    CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSeq_var &);
-    CORBA_ParDescriptionSeq_out (const CORBA_ParDescriptionSeq_out &);
-    CORBA_ParDescriptionSeq_out &operator= (const CORBA_ParDescriptionSeq_out &);
-    CORBA_ParDescriptionSeq_out &operator= (CORBA_ParDescriptionSeq *);
-    operator CORBA_ParDescriptionSeq *&();
-    CORBA_ParDescriptionSeq *&ptr (void);
-    CORBA_ParDescriptionSeq *operator-> (void);
-    CORBA_ParameterDescription &operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::OpDescriptionSeq_var
+// *************************************************************
 
-  private:
-    CORBA_ParDescriptionSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ParDescriptionSeq_var &);
-  };
+class TAO_Export OpDescriptionSeq_var
+{
+public:
+  OpDescriptionSeq_var (void); // default constructor
+  OpDescriptionSeq_var (OpDescriptionSeq *);
+  OpDescriptionSeq_var (const OpDescriptionSeq_var &); // copy constructor
+  ~OpDescriptionSeq_var (void); // destructor
+  
+  OpDescriptionSeq_var &operator= (OpDescriptionSeq *);
+  OpDescriptionSeq_var &operator= (const OpDescriptionSeq_var &);
+  OpDescriptionSeq *operator-> (void);
+  const OpDescriptionSeq *operator-> (void) const;
+  
+  operator const OpDescriptionSeq &() const;
+  operator OpDescriptionSeq &();
+  operator OpDescriptionSeq &() const;
+  operator OpDescriptionSeq *&(); // variable-size base types only
+  
+  OperationDescription &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const OpDescriptionSeq &in (void) const;
+  OpDescriptionSeq &inout (void);
+  OpDescriptionSeq *&out (void);
+  OpDescriptionSeq *_retn (void);
+  OpDescriptionSeq *ptr (void) const;
+
+private:
+  OpDescriptionSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_CONTEXTIDSEQ_CH_)
-#define _CORBA_CONTEXTIDSEQ_CH_
 
-  // *************************************************************
-  // ContextIdSeq
-  // *************************************************************
+#if !defined (_IR_OPDESCRIPTIONSEQ___OUT_CH_)
+#define _IR_OPDESCRIPTIONSEQ___OUT_CH_
+
+class TAO_Export OpDescriptionSeq_out
+{
+public:
+  OpDescriptionSeq_out (OpDescriptionSeq *&);
+  OpDescriptionSeq_out (OpDescriptionSeq_var &);
+  OpDescriptionSeq_out (const OpDescriptionSeq_out &);
+  OpDescriptionSeq_out &operator= (const OpDescriptionSeq_out &);
+  OpDescriptionSeq_out &operator= (OpDescriptionSeq *);
+  operator OpDescriptionSeq *&();
+  OpDescriptionSeq *&ptr (void);
+  OpDescriptionSeq *operator-> (void);
+  OperationDescription &operator[] (CORBA::ULong index);
+  
+private:
+  OpDescriptionSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const OpDescriptionSeq_var &);
+};
+
+
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OpDescriptionSeq;
+
 
-  class TAO_Export CORBA_ContextIdSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_ATTRDESCRIPTIONSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_ATTRDESCRIPTIONSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_ContextIdSeq (void); // default ctor
-    CORBA_ContextIdSeq (CORBA::ULong max); // uses max size
-    CORBA_ContextIdSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      char * *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_ContextIdSeq (const CORBA_ContextIdSeq &); // copy ctor
-    ~CORBA_ContextIdSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      AttributeDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (void); // Dtor.
+    // = Accessors.
+    AttributeDescription &operator[] (CORBA::ULong i);
+    const AttributeDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static AttributeDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (AttributeDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    AttributeDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const AttributeDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      AttributeDescription *data,
+      CORBA::Boolean release);
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTEXTIDSEQ___VAR_CH_)
-#define _CORBA_CONTEXTIDSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_ATTRDESCRIPTIONSEQ_CH_)
+#define _IR_ATTRDESCRIPTIONSEQ_CH_
+
+class AttrDescriptionSeq;
+class AttrDescriptionSeq_var;
 
 // *************************************************************
-  // class CORBA::ContextIdSeq_var
-  // *************************************************************
+// AttrDescriptionSeq
+// *************************************************************
 
-  class TAO_Export CORBA_ContextIdSeq_var
-  {
-  public:
-    CORBA_ContextIdSeq_var (void); // default constructor
-    CORBA_ContextIdSeq_var (CORBA_ContextIdSeq *);
-    CORBA_ContextIdSeq_var (const CORBA_ContextIdSeq_var &); // copy constructor
-    ~CORBA_ContextIdSeq_var (void); // destructor
-
-    CORBA_ContextIdSeq_var &operator= (CORBA_ContextIdSeq *);
-    CORBA_ContextIdSeq_var &operator= (const CORBA_ContextIdSeq_var &);
-    CORBA_ContextIdSeq *operator-> (void);
-    const CORBA_ContextIdSeq *operator-> (void) const;
-
-    operator const CORBA_ContextIdSeq &() const;
-    operator CORBA_ContextIdSeq &();
-    operator CORBA_ContextIdSeq &() const;
-    TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_ContextIdSeq &in (void) const;
-    CORBA_ContextIdSeq &inout (void);
-    CORBA_ContextIdSeq *&out (void);
-    CORBA_ContextIdSeq *_retn (void);
-    CORBA_ContextIdSeq *ptr (void) const;
+class TAO_Export AttrDescriptionSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<AttributeDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  AttrDescriptionSeq (void); // default ctor
+  AttrDescriptionSeq (CORBA::ULong max); // uses max size
+  AttrDescriptionSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    AttributeDescription *buffer, 
+    CORBA::Boolean release=0
+  );
+  AttrDescriptionSeq (const AttrDescriptionSeq &); // copy ctor
+  ~AttrDescriptionSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_ContextIdSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef AttrDescriptionSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTEXTIDSEQ___OUT_CH_)
-#define _CORBA_CONTEXTIDSEQ___OUT_CH_
+#if !defined (_IR_ATTRDESCRIPTIONSEQ___VAR_CH_)
+#define _IR_ATTRDESCRIPTIONSEQ___VAR_CH_
 
-  class TAO_Export CORBA_ContextIdSeq_out
-  {
-  public:
-    CORBA_ContextIdSeq_out (CORBA_ContextIdSeq *&);
-    CORBA_ContextIdSeq_out (CORBA_ContextIdSeq_var &);
-    CORBA_ContextIdSeq_out (const CORBA_ContextIdSeq_out &);
-    CORBA_ContextIdSeq_out &operator= (const CORBA_ContextIdSeq_out &);
-    CORBA_ContextIdSeq_out &operator= (CORBA_ContextIdSeq *);
-    operator CORBA_ContextIdSeq *&();
-    CORBA_ContextIdSeq *&ptr (void);
-    CORBA_ContextIdSeq *operator-> (void);
-    TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::AttrDescriptionSeq_var
+// *************************************************************
 
-  private:
-    CORBA_ContextIdSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ContextIdSeq_var &);
-  };
+class TAO_Export AttrDescriptionSeq_var
+{
+public:
+  AttrDescriptionSeq_var (void); // default constructor
+  AttrDescriptionSeq_var (AttrDescriptionSeq *);
+  AttrDescriptionSeq_var (const AttrDescriptionSeq_var &); // copy constructor
+  ~AttrDescriptionSeq_var (void); // destructor
+  
+  AttrDescriptionSeq_var &operator= (AttrDescriptionSeq *);
+  AttrDescriptionSeq_var &operator= (const AttrDescriptionSeq_var &);
+  AttrDescriptionSeq *operator-> (void);
+  const AttrDescriptionSeq *operator-> (void) const;
+  
+  operator const AttrDescriptionSeq &() const;
+  operator AttrDescriptionSeq &();
+  operator AttrDescriptionSeq &() const;
+  operator AttrDescriptionSeq *&(); // variable-size base types only
+  
+  AttributeDescription &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const AttrDescriptionSeq &in (void) const;
+  AttrDescriptionSeq &inout (void);
+  AttrDescriptionSeq *&out (void);
+  AttrDescriptionSeq *_retn (void);
+  AttrDescriptionSeq *ptr (void) const;
+
+private:
+  AttrDescriptionSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+#if !defined (_IR_ATTRDESCRIPTIONSEQ___OUT_CH_)
+#define _IR_ATTRDESCRIPTIONSEQ___OUT_CH_
+
+class TAO_Export AttrDescriptionSeq_out
+{
+public:
+  AttrDescriptionSeq_out (AttrDescriptionSeq *&);
+  AttrDescriptionSeq_out (AttrDescriptionSeq_var &);
+  AttrDescriptionSeq_out (const AttrDescriptionSeq_out &);
+  AttrDescriptionSeq_out &operator= (const AttrDescriptionSeq_out &);
+  AttrDescriptionSeq_out &operator= (AttrDescriptionSeq *);
+  operator AttrDescriptionSeq *&();
+  AttrDescriptionSeq *&ptr (void);
+  AttrDescriptionSeq *operator-> (void);
+  AttributeDescription &operator[] (CORBA::ULong index);
+  
+private:
+  AttrDescriptionSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const AttrDescriptionSeq_var &);
+};
 
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CH_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CH_
 
-    class _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+#endif /* end #if !defined */
 
-      _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void);
-      _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_ExceptionDef* *value,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs);
-      virtual ~_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void);
-      _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs);
-      TAO_Object_Manager<CORBA::ExceptionDef,CORBA::ExceptionDef_var> operator[] (CORBA::ULong index) const;
-      static CORBA_ExceptionDef **allocbuf (CORBA::ULong nelems);
-      static void freebuf (CORBA_ExceptionDef **buffer);
-      // The Base_Sequence functions, please see tao/Sequence.h
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      CORBA_ExceptionDef* *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_ExceptionDef* *get_buffer (void) const;
-      virtual void _shrink_buffer (CORBA::ULong nl, CORBA::ULong ol);
-      virtual void _downcast (
-          void* target,
-          CORBA_Object *src,
-          CORBA_Environment &ACE_TRY_ENV =
-            TAO_default_environment ()
-        );
-      virtual CORBA_Object* _upcast (void *src) const;
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttrDescriptionSeq;
 
-    };
+
+#if !defined (_IR_INTERFACEDEF___PTR_CH_)
+#define _IR_INTERFACEDEF___PTR_CH_
+
+class InterfaceDef;
+typedef InterfaceDef *InterfaceDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_INTERFACEDEF___VAR_CH_)
+#define _IR_INTERFACEDEF___VAR_CH_
+
+class TAO_Export InterfaceDef_var
+{
+public:
+  InterfaceDef_var (void); // default constructor
+  InterfaceDef_var (InterfaceDef_ptr);
+  InterfaceDef_var (const InterfaceDef_var &); // copy constructor
+  ~InterfaceDef_var (void); // destructor
+  
+  InterfaceDef_var &operator= (InterfaceDef_ptr);
+  InterfaceDef_var &operator= (const InterfaceDef_var &);
+  InterfaceDef_ptr operator-> (void) const;
+  
+  operator const InterfaceDef_ptr &() const;
+  operator InterfaceDef_ptr &();
+  // in, inout, out, _retn 
+  InterfaceDef_ptr in (void) const;
+  InterfaceDef_ptr &inout (void);
+  InterfaceDef_ptr &out (void);
+  InterfaceDef_ptr _retn (void);
+  InterfaceDef_ptr ptr (void) const;
+
+private:
+  InterfaceDef_ptr ptr_;
+};
 
-#if !defined (_CORBA_EXCEPTIONDEFSEQ_CH_)
-#define _CORBA_EXCEPTIONDEFSEQ_CH_
 
-  // *************************************************************
-  // ExceptionDefSeq
-  // *************************************************************
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_INTERFACEDEF___OUT_CH_)
+#define _IR_INTERFACEDEF___OUT_CH_
+
+class TAO_Export InterfaceDef_out
+{
+public:
+  InterfaceDef_out (InterfaceDef_ptr &);
+  InterfaceDef_out (InterfaceDef_var &);
+  InterfaceDef_out (const InterfaceDef_out &);
+  InterfaceDef_out &operator= (const InterfaceDef_out &);
+  InterfaceDef_out &operator= (const InterfaceDef_var &);
+  InterfaceDef_out &operator= (InterfaceDef_ptr);
+  operator InterfaceDef_ptr &();
+  InterfaceDef_ptr &ptr (void);
+  InterfaceDef_ptr operator-> (void);
+  
+private:
+  InterfaceDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_INTERFACEDEF_CH_)
+#define _IR_INTERFACEDEF_CH_
+
+class TAO_Export InterfaceDef: public virtual Container, public virtual Contained, public virtual IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef InterfaceDef_ptr _ptr_type;
+  typedef InterfaceDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static InterfaceDef_ptr _duplicate (InterfaceDef_ptr obj);
+  static InterfaceDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static InterfaceDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static InterfaceDef_ptr _nil (void)
+    {
+      return (InterfaceDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::InterfaceDefSeq * base_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void base_interfaces (
+      const IR::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_abstract (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_abstract (
+      CORBA::Boolean is_abstract,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_local (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_local (
+      CORBA::Boolean is_local,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_a (
+      const char * interface_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::AttributeDef_ptr create_attribute (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr type,
+      IR::AttributeMode mode,
+      const IR::ExceptionDefSeq & get_exceptions,
+      const IR::ExceptionDefSeq & put_exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::OperationDef_ptr create_operation (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr result,
+      IR::OperationMode mode,
+      const IR::ParDescriptionSeq & params,
+      const IR::ExceptionDefSeq & exceptions,
+      const IR::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  InterfaceDef (void);
+  InterfaceDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~InterfaceDef (void);
+private:
+  InterfaceDef (const InterfaceDef &);
+  void operator= (const InterfaceDef &);
+};
+
+class TAO_IR_InterfaceDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_InterfaceDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_InterfaceDef_Default_Proxy_Factory (void);
+  
+  virtual InterfaceDef_ptr create_proxy (
+      InterfaceDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_InterfaceDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_InterfaceDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_InterfaceDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  InterfaceDef_ptr create_proxy (
+      InterfaceDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_InterfaceDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_InterfaceDef_Proxy_Factory_Adapter (void);
+  TAO_IR_InterfaceDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_InterfaceDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_InterfaceDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_InterfaceDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_InterfaceDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_InterfaceDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, InterfaceDef)
+  {
+  public:
+    TAO_IR_InterfaceDef_Smart_Proxy_Base (::IR::InterfaceDef_ptr proxy);
+    ~TAO_IR_InterfaceDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::InterfaceDefSeq * base_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void base_interfaces (
+      const IR::InterfaceDefSeq & base_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_abstract (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_abstract (
+      CORBA::Boolean is_abstract,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_local (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_local (
+      CORBA::Boolean is_local,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_a (
+      const char * interface_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::AttributeDef_ptr create_attribute (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr type,
+      IR::AttributeMode mode,
+      const IR::ExceptionDefSeq & get_exceptions,
+      const IR::ExceptionDefSeq & put_exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::OperationDef_ptr create_operation (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr result,
+      IR::OperationMode mode,
+      const IR::ParDescriptionSeq & params,
+      const IR::ExceptionDefSeq & exceptions,
+      const IR::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::InterfaceDef_var base_proxy_;
+};
+
+
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDef;
+
+struct InterfaceDescription;
+class InterfaceDescription_var;
+
+struct TAO_Export InterfaceDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef InterfaceDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  ACE_NESTED_CLASS (IR, OpDescriptionSeq) operations;
+  ACE_NESTED_CLASS (IR, AttrDescriptionSeq) attributes;
+  ACE_NESTED_CLASS (IR, RepositoryIdSeq) base_interfaces;
+  CORBA::TypeCode_var type;
+  CORBA::Boolean is_abstract;
+  CORBA::Boolean is_local;
+};
+
+class TAO_Export InterfaceDescription_var
+{
+public:
+  InterfaceDescription_var (void); // default constructor
+  InterfaceDescription_var (InterfaceDescription *);
+  InterfaceDescription_var (const InterfaceDescription_var &); // copy constructor
+  ~InterfaceDescription_var (void); // destructor
+  
+  InterfaceDescription_var &operator= (InterfaceDescription *);
+  InterfaceDescription_var &operator= (const InterfaceDescription_var &);
+  InterfaceDescription *operator-> (void);
+  const InterfaceDescription *operator-> (void) const;
+  
+  operator const InterfaceDescription &() const;
+  operator InterfaceDescription &();
+  operator InterfaceDescription &() const;
+  operator InterfaceDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const InterfaceDescription &in (void) const;
+  InterfaceDescription &inout (void);
+  InterfaceDescription *&out (void);
+  InterfaceDescription *_retn (void);
+  InterfaceDescription *ptr (void) const;
+
+private:
+  InterfaceDescription *ptr_;
+};
+
+class TAO_Export InterfaceDescription_out
+{
+public:
+  InterfaceDescription_out (InterfaceDescription *&);
+  InterfaceDescription_out (InterfaceDescription_var &);
+  InterfaceDescription_out (const InterfaceDescription_out &);
+  InterfaceDescription_out &operator= (const InterfaceDescription_out &);
+  InterfaceDescription_out &operator= (InterfaceDescription *);
+  operator InterfaceDescription *&();
+  InterfaceDescription *&ptr (void);
+  InterfaceDescription *operator-> (void);
+  
+private:
+  InterfaceDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const InterfaceDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDescription;
+
+struct ValueMember;
+class ValueMember_var;
+
+struct TAO_Export ValueMember
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ValueMember_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  CORBA::TypeCode_var type;
+  TAO_Object_Field_T<ACE_NESTED_CLASS (IR, IDLType), ACE_NESTED_CLASS (IR, IDLType_var)> type_def;
+  CORBA::Visibility access;
+};
+
+class TAO_Export ValueMember_var
+{
+public:
+  ValueMember_var (void); // default constructor
+  ValueMember_var (ValueMember *);
+  ValueMember_var (const ValueMember_var &); // copy constructor
+  ~ValueMember_var (void); // destructor
+  
+  ValueMember_var &operator= (ValueMember *);
+  ValueMember_var &operator= (const ValueMember_var &);
+  ValueMember *operator-> (void);
+  const ValueMember *operator-> (void) const;
+  
+  operator const ValueMember &() const;
+  operator ValueMember &();
+  operator ValueMember &() const;
+  operator ValueMember *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const ValueMember &in (void) const;
+  ValueMember &inout (void);
+  ValueMember *&out (void);
+  ValueMember *_retn (void);
+  ValueMember *ptr (void) const;
+
+private:
+  ValueMember *ptr_;
+};
+
+class TAO_Export ValueMember_out
+{
+public:
+  ValueMember_out (ValueMember *&);
+  ValueMember_out (ValueMember_var &);
+  ValueMember_out (const ValueMember_out &);
+  ValueMember_out &operator= (const ValueMember_out &);
+  ValueMember_out &operator= (ValueMember *);
+  operator ValueMember *&();
+  ValueMember *&ptr (void);
+  ValueMember *operator-> (void);
+  
+private:
+  ValueMember *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ValueMember_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMember;
+
 
-  class TAO_Export CORBA_ExceptionDefSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Object_Sequence<CORBA_ExceptionDef,CORBA_ExceptionDef_var>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_VALUEMEMBERSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_VALUEMEMBERSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ValueMemberSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_ExceptionDefSeq (void); // default ctor
-    CORBA_ExceptionDefSeq (CORBA::ULong max); // uses max size
-    CORBA_ExceptionDefSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_ValueMemberSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      CORBA_ExceptionDef_ptr *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_ExceptionDefSeq (const CORBA_ExceptionDefSeq &); // copy ctor
-    ~CORBA_ExceptionDefSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      ValueMember *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_ValueMemberSeq (const _TAO_Unbounded_Sequence_IR_ValueMemberSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_ValueMemberSeq &operator= (const _TAO_Unbounded_Sequence_IR_ValueMemberSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_ValueMemberSeq (void); // Dtor.
+    // = Accessors.
+    ValueMember &operator[] (CORBA::ULong i);
+    const ValueMember &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static ValueMember *allocbuf (CORBA::ULong size);
+    static void freebuf (ValueMember *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    ValueMember *get_buffer (CORBA::Boolean orphan = 0);
+    const ValueMember *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      ValueMember *data,
+      CORBA::Boolean release);
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_EXCEPTIONDEFSEQ___VAR_CH_)
-#define _CORBA_EXCEPTIONDEFSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_VALUEMEMBERSEQ_CH_)
+#define _IR_VALUEMEMBERSEQ_CH_
+
+class ValueMemberSeq;
+class ValueMemberSeq_var;
 
 // *************************************************************
-  // class CORBA::ExceptionDefSeq_var
-  // *************************************************************
+// ValueMemberSeq
+// *************************************************************
 
-  class TAO_Export CORBA_ExceptionDefSeq_var
-  {
-  public:
-    CORBA_ExceptionDefSeq_var (void); // default constructor
-    CORBA_ExceptionDefSeq_var (CORBA_ExceptionDefSeq *);
-    CORBA_ExceptionDefSeq_var (const CORBA_ExceptionDefSeq_var &); // copy constructor
-    ~CORBA_ExceptionDefSeq_var (void); // destructor
-
-    CORBA_ExceptionDefSeq_var &operator= (CORBA_ExceptionDefSeq *);
-    CORBA_ExceptionDefSeq_var &operator= (const CORBA_ExceptionDefSeq_var &);
-    CORBA_ExceptionDefSeq *operator-> (void);
-    const CORBA_ExceptionDefSeq *operator-> (void) const;
-
-    operator const CORBA_ExceptionDefSeq &() const;
-    operator CORBA_ExceptionDefSeq &();
-    operator CORBA_ExceptionDefSeq &() const;
-    TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var> operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_ExceptionDefSeq &in (void) const;
-    CORBA_ExceptionDefSeq &inout (void);
-    CORBA_ExceptionDefSeq *&out (void);
-    CORBA_ExceptionDefSeq *_retn (void);
-    CORBA_ExceptionDefSeq *ptr (void) const;
+class TAO_Export ValueMemberSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ValueMemberSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<ValueMember>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ValueMemberSeq (void); // default ctor
+  ValueMemberSeq (CORBA::ULong max); // uses max size
+  ValueMemberSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ValueMember *buffer, 
+    CORBA::Boolean release=0
+  );
+  ValueMemberSeq (const ValueMemberSeq &); // copy ctor
+  ~ValueMemberSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_ExceptionDefSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ValueMemberSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_EXCEPTIONDEFSEQ___OUT_CH_)
-#define _CORBA_EXCEPTIONDEFSEQ___OUT_CH_
+#if !defined (_IR_VALUEMEMBERSEQ___VAR_CH_)
+#define _IR_VALUEMEMBERSEQ___VAR_CH_
 
-  class TAO_Export CORBA_ExceptionDefSeq_out
-  {
-  public:
-    CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq *&);
-    CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq_var &);
-    CORBA_ExceptionDefSeq_out (const CORBA_ExceptionDefSeq_out &);
-    CORBA_ExceptionDefSeq_out &operator= (const CORBA_ExceptionDefSeq_out &);
-    CORBA_ExceptionDefSeq_out &operator= (CORBA_ExceptionDefSeq *);
-    operator CORBA_ExceptionDefSeq *&();
-    CORBA_ExceptionDefSeq *&ptr (void);
-    CORBA_ExceptionDefSeq *operator-> (void);
-    TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var> operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::ValueMemberSeq_var
+// *************************************************************
 
-  private:
-    CORBA_ExceptionDefSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ExceptionDefSeq_var &);
-  };
+class TAO_Export ValueMemberSeq_var
+{
+public:
+  ValueMemberSeq_var (void); // default constructor
+  ValueMemberSeq_var (ValueMemberSeq *);
+  ValueMemberSeq_var (const ValueMemberSeq_var &); // copy constructor
+  ~ValueMemberSeq_var (void); // destructor
+  
+  ValueMemberSeq_var &operator= (ValueMemberSeq *);
+  ValueMemberSeq_var &operator= (const ValueMemberSeq_var &);
+  ValueMemberSeq *operator-> (void);
+  const ValueMemberSeq *operator-> (void) const;
+  
+  operator const ValueMemberSeq &() const;
+  operator ValueMemberSeq &();
+  operator ValueMemberSeq &() const;
+  operator ValueMemberSeq *&(); // variable-size base types only
+  
+  ValueMember &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ValueMemberSeq &in (void) const;
+  ValueMemberSeq &inout (void);
+  ValueMemberSeq *&out (void);
+  ValueMemberSeq *_retn (void);
+  ValueMemberSeq *ptr (void) const;
+
+private:
+  ValueMemberSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+#if !defined (_IR_VALUEMEMBERSEQ___OUT_CH_)
+#define _IR_VALUEMEMBERSEQ___OUT_CH_
+
+class TAO_Export ValueMemberSeq_out
+{
+public:
+  ValueMemberSeq_out (ValueMemberSeq *&);
+  ValueMemberSeq_out (ValueMemberSeq_var &);
+  ValueMemberSeq_out (const ValueMemberSeq_out &);
+  ValueMemberSeq_out &operator= (const ValueMemberSeq_out &);
+  ValueMemberSeq_out &operator= (ValueMemberSeq *);
+  operator ValueMemberSeq *&();
+  ValueMemberSeq *&ptr (void);
+  ValueMemberSeq *operator-> (void);
+  ValueMember &operator[] (CORBA::ULong index);
+  
+private:
+  ValueMemberSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ValueMemberSeq_var &);
+};
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CH_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CH_
 
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+#endif /* end #if !defined */
 
-      _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void); // Default constructor.
-      _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_ExceptionDescription *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs);
-      _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs);
-      virtual ~_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void); // Dtor.
-      // = Accessors.
-      CORBA_ExceptionDescription &operator[] (CORBA::ULong i);
-      const CORBA_ExceptionDescription &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static CORBA_ExceptionDescription *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA_ExceptionDescription *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberSeq;
 
-      CORBA_ExceptionDescription *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_ExceptionDescription *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        CORBA_ExceptionDescription *data,
-        CORBA::Boolean release);
-    };
+
+#if !defined (_IR_VALUEMEMBERDEF___PTR_CH_)
+#define _IR_VALUEMEMBERDEF___PTR_CH_
+
+class ValueMemberDef;
+typedef ValueMemberDef *ValueMemberDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_VALUEMEMBERDEF___VAR_CH_)
+#define _IR_VALUEMEMBERDEF___VAR_CH_
+
+class TAO_Export ValueMemberDef_var
+{
+public:
+  ValueMemberDef_var (void); // default constructor
+  ValueMemberDef_var (ValueMemberDef_ptr);
+  ValueMemberDef_var (const ValueMemberDef_var &); // copy constructor
+  ~ValueMemberDef_var (void); // destructor
+  
+  ValueMemberDef_var &operator= (ValueMemberDef_ptr);
+  ValueMemberDef_var &operator= (const ValueMemberDef_var &);
+  ValueMemberDef_ptr operator-> (void) const;
+  
+  operator const ValueMemberDef_ptr &() const;
+  operator ValueMemberDef_ptr &();
+  // in, inout, out, _retn 
+  ValueMemberDef_ptr in (void) const;
+  ValueMemberDef_ptr &inout (void);
+  ValueMemberDef_ptr &out (void);
+  ValueMemberDef_ptr _retn (void);
+  ValueMemberDef_ptr ptr (void) const;
+
+private:
+  ValueMemberDef_ptr ptr_;
+};
 
-#if !defined (_CORBA_EXCDESCRIPTIONSEQ_CH_)
-#define _CORBA_EXCDESCRIPTIONSEQ_CH_
 
-  // *************************************************************
-  // ExcDescriptionSeq
-  // *************************************************************
+#endif /* end #if !defined */
 
-  class TAO_Export CORBA_ExcDescriptionSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA_ExceptionDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-  {
-  public:
-    CORBA_ExcDescriptionSeq (void); // default ctor
-    CORBA_ExcDescriptionSeq (CORBA::ULong max); // uses max size
-    CORBA_ExcDescriptionSeq (
-      CORBA::ULong max,
-      CORBA::ULong length,
-      CORBA_ExceptionDescription *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_ExcDescriptionSeq (const CORBA_ExcDescriptionSeq &); // copy ctor
-    ~CORBA_ExcDescriptionSeq (void); // dtor
 
-    static void _tao_any_destructor (void*);
-  };
+#if !defined (_IR_VALUEMEMBERDEF___OUT_CH_)
+#define _IR_VALUEMEMBERDEF___OUT_CH_
+
+class TAO_Export ValueMemberDef_out
+{
+public:
+  ValueMemberDef_out (ValueMemberDef_ptr &);
+  ValueMemberDef_out (ValueMemberDef_var &);
+  ValueMemberDef_out (const ValueMemberDef_out &);
+  ValueMemberDef_out &operator= (const ValueMemberDef_out &);
+  ValueMemberDef_out &operator= (const ValueMemberDef_var &);
+  ValueMemberDef_out &operator= (ValueMemberDef_ptr);
+  operator ValueMemberDef_ptr &();
+  ValueMemberDef_ptr &ptr (void);
+  ValueMemberDef_ptr operator-> (void);
+  
+private:
+  ValueMemberDef_ptr &ptr_;
+};
+
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_EXCDESCRIPTIONSEQ___VAR_CH_)
-#define _CORBA_EXCDESCRIPTIONSEQ___VAR_CH_
+#if !defined (_IR_VALUEMEMBERDEF_CH_)
+#define _IR_VALUEMEMBERDEF_CH_
 
-// *************************************************************
-  // class CORBA::ExcDescriptionSeq_var
-  // *************************************************************
+class TAO_Export ValueMemberDef: public virtual Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ValueMemberDef_ptr _ptr_type;
+  typedef ValueMemberDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ValueMemberDef_ptr _duplicate (ValueMemberDef_ptr obj);
+  static ValueMemberDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ValueMemberDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ValueMemberDef_ptr _nil (void)
+    {
+      return (ValueMemberDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      IR::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Visibility access (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void access (
+      CORBA::Visibility access,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  ValueMemberDef (void);
+  ValueMemberDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ValueMemberDef (void);
+private:
+  ValueMemberDef (const ValueMemberDef &);
+  void operator= (const ValueMemberDef &);
+};
+
+class TAO_IR_ValueMemberDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ValueMemberDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ValueMemberDef_Default_Proxy_Factory (void);
+  
+  virtual ValueMemberDef_ptr create_proxy (
+      ValueMemberDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ValueMemberDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ValueMemberDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ValueMemberDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ValueMemberDef_ptr create_proxy (
+      ValueMemberDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ValueMemberDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ValueMemberDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ValueMemberDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ValueMemberDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ValueMemberDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
 
-  class TAO_Export CORBA_ExcDescriptionSeq_var
+  typedef ACE_Singleton<TAO_IR_ValueMemberDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ValueMemberDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ValueMemberDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, ValueMemberDef)
   {
   public:
-    CORBA_ExcDescriptionSeq_var (void); // default constructor
-    CORBA_ExcDescriptionSeq_var (CORBA_ExcDescriptionSeq *);
-    CORBA_ExcDescriptionSeq_var (const CORBA_ExcDescriptionSeq_var &); // copy constructor
-    ~CORBA_ExcDescriptionSeq_var (void); // destructor
-
-    CORBA_ExcDescriptionSeq_var &operator= (CORBA_ExcDescriptionSeq *);
-    CORBA_ExcDescriptionSeq_var &operator= (const CORBA_ExcDescriptionSeq_var &);
-    CORBA_ExcDescriptionSeq *operator-> (void);
-    const CORBA_ExcDescriptionSeq *operator-> (void) const;
-
-    operator const CORBA_ExcDescriptionSeq &() const;
-    operator CORBA_ExcDescriptionSeq &();
-    operator CORBA_ExcDescriptionSeq &() const;
-    CORBA_ExceptionDescription &operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_ExcDescriptionSeq &in (void) const;
-    CORBA_ExcDescriptionSeq &inout (void);
-    CORBA_ExcDescriptionSeq *&out (void);
-    CORBA_ExcDescriptionSeq *_retn (void);
-    CORBA_ExcDescriptionSeq *ptr (void) const;
+    TAO_IR_ValueMemberDef_Smart_Proxy_Base (::IR::ValueMemberDef_ptr proxy);
+    ~TAO_IR_ValueMemberDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::TypeCode_ptr type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::IDLType_ptr type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void type_def (
+      IR::IDLType_ptr type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Visibility access (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void access (
+      CORBA::Visibility access,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::ValueMemberDef_var base_proxy_;
+};
 
-  private:
-    CORBA_ExcDescriptionSeq *ptr_;
-  };
 
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberDef;
+
+
+#if !defined (_IR_VALUEDEF___PTR_CH_)
+#define _IR_VALUEDEF___PTR_CH_
+
+class ValueDef;
+typedef ValueDef *ValueDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_EXCDESCRIPTIONSEQ___OUT_CH_)
-#define _CORBA_EXCDESCRIPTIONSEQ___OUT_CH_
+#if !defined (_IR_VALUEDEF___VAR_CH_)
+#define _IR_VALUEDEF___VAR_CH_
+
+class TAO_Export ValueDef_var
+{
+public:
+  ValueDef_var (void); // default constructor
+  ValueDef_var (ValueDef_ptr);
+  ValueDef_var (const ValueDef_var &); // copy constructor
+  ~ValueDef_var (void); // destructor
+  
+  ValueDef_var &operator= (ValueDef_ptr);
+  ValueDef_var &operator= (const ValueDef_var &);
+  ValueDef_ptr operator-> (void) const;
+  
+  operator const ValueDef_ptr &() const;
+  operator ValueDef_ptr &();
+  // in, inout, out, _retn 
+  ValueDef_ptr in (void) const;
+  ValueDef_ptr &inout (void);
+  ValueDef_ptr &out (void);
+  ValueDef_ptr _retn (void);
+  ValueDef_ptr ptr (void) const;
+
+private:
+  ValueDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_ExcDescriptionSeq_out
-  {
-  public:
-    CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSeq *&);
-    CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSeq_var &);
-    CORBA_ExcDescriptionSeq_out (const CORBA_ExcDescriptionSeq_out &);
-    CORBA_ExcDescriptionSeq_out &operator= (const CORBA_ExcDescriptionSeq_out &);
-    CORBA_ExcDescriptionSeq_out &operator= (CORBA_ExcDescriptionSeq *);
-    operator CORBA_ExcDescriptionSeq *&();
-    CORBA_ExcDescriptionSeq *&ptr (void);
-    CORBA_ExcDescriptionSeq *operator-> (void);
-    CORBA_ExceptionDescription &operator[] (CORBA::ULong index);
 
-  private:
-    CORBA_ExcDescriptionSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ExcDescriptionSeq_var &);
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_VALUEDEF___OUT_CH_)
+#define _IR_VALUEDEF___OUT_CH_
+
+class TAO_Export ValueDef_out
+{
+public:
+  ValueDef_out (ValueDef_ptr &);
+  ValueDef_out (ValueDef_var &);
+  ValueDef_out (const ValueDef_out &);
+  ValueDef_out &operator= (const ValueDef_out &);
+  ValueDef_out &operator= (const ValueDef_var &);
+  ValueDef_out &operator= (ValueDef_ptr);
+  operator ValueDef_ptr &();
+  ValueDef_ptr &ptr (void);
+  ValueDef_ptr operator-> (void);
+  
+private:
+  ValueDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-#if !defined (_CORBA_OPERATIONDEF___VAR_CH_)
-#define _CORBA_OPERATIONDEF___VAR_CH_
 
-  class TAO_Export CORBA_OperationDef_var
-  {
-  public:
-    CORBA_OperationDef_var (void); // default constructor
-    CORBA_OperationDef_var (CORBA_OperationDef_ptr);
-    CORBA_OperationDef_var (const CORBA_OperationDef_var &); // copy constructor
-    ~CORBA_OperationDef_var (void); // destructor
+#if !defined (_IR_VALUEDEF_CH_)
+#define _IR_VALUEDEF_CH_
 
-    CORBA_OperationDef_var &operator= (CORBA_OperationDef_ptr);
-    CORBA_OperationDef_var &operator= (const CORBA_OperationDef_var &);
-    CORBA_OperationDef_ptr operator-> (void) const;
+class TAO_Export ValueDef: public virtual Container, public virtual Contained, public virtual IDLType
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ValueDef_ptr _ptr_type;
+  typedef ValueDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-    operator const CORBA_OperationDef_ptr &() const;
-    operator CORBA_OperationDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_OperationDef_ptr in (void) const;
-    CORBA_OperationDef_ptr &inout (void);
-    CORBA_OperationDef_ptr &out (void);
-    CORBA_OperationDef_ptr _retn (void);
-    CORBA_OperationDef_ptr ptr (void) const;
+  // the static operations
+  static ValueDef_ptr _duplicate (ValueDef_ptr obj);
+  static ValueDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ValueDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ValueDef_ptr _nil (void)
+    {
+      return (ValueDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::InterfaceDefSeq * supported_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void supported_interfaces (
+      const IR::InterfaceDefSeq & supported_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::InitializerSeq * initializers (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void initializers (
+      const IR::InitializerSeq & initializers,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueDef_ptr base_value (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void base_value (
+      IR::ValueDef_ptr base_value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueDefSeq * abstract_base_values (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void abstract_base_values (
+      const IR::ValueDefSeq & abstract_base_values,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_abstract (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_abstract (
+      CORBA::Boolean is_abstract,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_custom (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_custom (
+      CORBA::Boolean is_custom,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_truncatable (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_truncatable (
+      CORBA::Boolean is_truncatable,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_a (
+      const char * id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueMemberDef_ptr create_value_member (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr type,
+      CORBA::Visibility access,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::AttributeDef_ptr create_attribute (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr type,
+      IR::AttributeMode mode,
+      const IR::ExceptionDefSeq & get_exceptions,
+      const IR::ExceptionDefSeq & put_exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::OperationDef_ptr create_operation (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr result,
+      IR::OperationMode mode,
+      const IR::ParDescriptionSeq & params,
+      const IR::ExceptionDefSeq & exceptions,
+      const IR::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
 
-  private:
-    CORBA_OperationDef_ptr ptr_;
+protected:
+  ValueDef (void);
+  ValueDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ValueDef (void);
+private:
+  ValueDef (const ValueDef &);
+  void operator= (const ValueDef &);
+};
+
+class TAO_IR_ValueDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ValueDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ValueDef_Default_Proxy_Factory (void);
+  
+  virtual ValueDef_ptr create_proxy (
+      ValueDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ValueDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ValueDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ValueDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ValueDef_ptr create_proxy (
+      ValueDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ValueDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ValueDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ValueDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ValueDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ValueDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
+  typedef ACE_Singleton<TAO_IR_ValueDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ValueDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ValueDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, ValueDef)
+  {
+  public:
+    TAO_IR_ValueDef_Smart_Proxy_Base (::IR::ValueDef_ptr proxy);
+    ~TAO_IR_ValueDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::InterfaceDefSeq * supported_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void supported_interfaces (
+      const IR::InterfaceDefSeq & supported_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::InitializerSeq * initializers (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void initializers (
+      const IR::InitializerSeq & initializers,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueDef_ptr base_value (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void base_value (
+      IR::ValueDef_ptr base_value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueDefSeq * abstract_base_values (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void abstract_base_values (
+      const IR::ValueDefSeq & abstract_base_values,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_abstract (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_abstract (
+      CORBA::Boolean is_abstract,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_custom (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_custom (
+      CORBA::Boolean is_custom,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_truncatable (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void is_truncatable (
+      CORBA::Boolean is_truncatable,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_a (
+      const char * id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueMemberDef_ptr create_value_member (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr type,
+      CORBA::Visibility access,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::AttributeDef_ptr create_attribute (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr type,
+      IR::AttributeMode mode,
+      const IR::ExceptionDefSeq & get_exceptions,
+      const IR::ExceptionDefSeq & put_exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::OperationDef_ptr create_operation (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::IDLType_ptr result,
+      IR::OperationMode mode,
+      const IR::ParDescriptionSeq & params,
+      const IR::ExceptionDefSeq & exceptions,
+      const IR::ContextIdSeq & contexts,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::ValueDef_var base_proxy_;
+};
+
 
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDef;
+
+struct ValueDescription;
+class ValueDescription_var;
+
+struct TAO_Export ValueDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ValueDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  CORBA::Boolean is_abstract;
+  CORBA::Boolean is_custom;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  ACE_NESTED_CLASS (IR, OpDescriptionSeq) operations;
+  ACE_NESTED_CLASS (IR, AttrDescriptionSeq) attributes;
+  ACE_NESTED_CLASS (IR, ValueMemberSeq) members;
+  ACE_NESTED_CLASS (IR, InitializerSeq) initializers;
+  ACE_NESTED_CLASS (IR, RepositoryIdSeq) supported_interfaces;
+  ACE_NESTED_CLASS (IR, RepositoryIdSeq) abstract_base_values;
+  CORBA::Boolean is_truncatable;
+  TAO_String_Manager base_value;
+  CORBA::TypeCode_var type;
+};
+
+class TAO_Export ValueDescription_var
+{
+public:
+  ValueDescription_var (void); // default constructor
+  ValueDescription_var (ValueDescription *);
+  ValueDescription_var (const ValueDescription_var &); // copy constructor
+  ~ValueDescription_var (void); // destructor
+  
+  ValueDescription_var &operator= (ValueDescription *);
+  ValueDescription_var &operator= (const ValueDescription_var &);
+  ValueDescription *operator-> (void);
+  const ValueDescription *operator-> (void) const;
+  
+  operator const ValueDescription &() const;
+  operator ValueDescription &();
+  operator ValueDescription &() const;
+  operator ValueDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const ValueDescription &in (void) const;
+  ValueDescription &inout (void);
+  ValueDescription *&out (void);
+  ValueDescription *_retn (void);
+  ValueDescription *ptr (void) const;
+
+private:
+  ValueDescription *ptr_;
+};
+
+class TAO_Export ValueDescription_out
+{
+public:
+  ValueDescription_out (ValueDescription *&);
+  ValueDescription_out (ValueDescription_var &);
+  ValueDescription_out (const ValueDescription_out &);
+  ValueDescription_out &operator= (const ValueDescription_out &);
+  ValueDescription_out &operator= (ValueDescription *);
+  operator ValueDescription *&();
+  ValueDescription *&ptr (void);
+  ValueDescription *operator-> (void);
+  
+private:
+  ValueDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ValueDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDescription;
+
+
+#if !defined (_IR_VALUEBOXDEF___PTR_CH_)
+#define _IR_VALUEBOXDEF___PTR_CH_
+
+class ValueBoxDef;
+typedef ValueBoxDef *ValueBoxDef_ptr;
 
-#if !defined (_CORBA_OPERATIONDEF___OUT_CH_)
-#define _CORBA_OPERATIONDEF___OUT_CH_
+#endif /* end #if !defined */
 
-  class TAO_Export CORBA_OperationDef_out
-  {
-  public:
-    CORBA_OperationDef_out (CORBA_OperationDef_ptr &);
-    CORBA_OperationDef_out (CORBA_OperationDef_var &);
-    CORBA_OperationDef_out (const CORBA_OperationDef_out &);
-    CORBA_OperationDef_out &operator= (const CORBA_OperationDef_out &);
-    CORBA_OperationDef_out &operator= (const CORBA_OperationDef_var &);
-    CORBA_OperationDef_out &operator= (CORBA_OperationDef_ptr);
-    operator CORBA_OperationDef_ptr &();
-    CORBA_OperationDef_ptr &ptr (void);
-    CORBA_OperationDef_ptr operator-> (void);
 
-  private:
-    CORBA_OperationDef_ptr &ptr_;
-  };
+#if !defined (_IR_VALUEBOXDEF___VAR_CH_)
+#define _IR_VALUEBOXDEF___VAR_CH_
+
+class TAO_Export ValueBoxDef_var
+{
+public:
+  ValueBoxDef_var (void); // default constructor
+  ValueBoxDef_var (ValueBoxDef_ptr);
+  ValueBoxDef_var (const ValueBoxDef_var &); // copy constructor
+  ~ValueBoxDef_var (void); // destructor
+  
+  ValueBoxDef_var &operator= (ValueBoxDef_ptr);
+  ValueBoxDef_var &operator= (const ValueBoxDef_var &);
+  ValueBoxDef_ptr operator-> (void) const;
+  
+  operator const ValueBoxDef_ptr &() const;
+  operator ValueBoxDef_ptr &();
+  // in, inout, out, _retn 
+  ValueBoxDef_ptr in (void) const;
+  ValueBoxDef_ptr &inout (void);
+  ValueBoxDef_ptr &out (void);
+  ValueBoxDef_ptr _retn (void);
+  ValueBoxDef_ptr ptr (void) const;
+
+private:
+  ValueBoxDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_OPERATIONDEF_CH_)
-#define _CORBA_OPERATIONDEF_CH_
+#if !defined (_IR_VALUEBOXDEF___OUT_CH_)
+#define _IR_VALUEBOXDEF___OUT_CH_
+
+class TAO_Export ValueBoxDef_out
+{
+public:
+  ValueBoxDef_out (ValueBoxDef_ptr &);
+  ValueBoxDef_out (ValueBoxDef_var &);
+  ValueBoxDef_out (const ValueBoxDef_out &);
+  ValueBoxDef_out &operator= (const ValueBoxDef_out &);
+  ValueBoxDef_out &operator= (const ValueBoxDef_var &);
+  ValueBoxDef_out &operator= (ValueBoxDef_ptr);
+  operator ValueBoxDef_ptr &();
+  ValueBoxDef_ptr &ptr (void);
+  ValueBoxDef_ptr operator-> (void);
+  
+private:
+  ValueBoxDef_ptr &ptr_;
+};
 
-class TAO_Export CORBA_OperationDef: public virtual CORBA_Contained
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_VALUEBOXDEF_CH_)
+#define _IR_VALUEBOXDEF_CH_
+
+class TAO_Export ValueBoxDef: public virtual TypedefDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ValueBoxDef_ptr _ptr_type;
+  typedef ValueBoxDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ValueBoxDef_ptr _duplicate (ValueBoxDef_ptr obj);
+  static ValueBoxDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ValueBoxDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ValueBoxDef_ptr _nil (void)
+    {
+      return (ValueBoxDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::IDLType_ptr original_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void original_type_def (
+      IR::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  ValueBoxDef (void);
+  ValueBoxDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ValueBoxDef (void);
+private:
+  ValueBoxDef (const ValueBoxDef &);
+  void operator= (const ValueBoxDef &);
+};
+
+class TAO_IR_ValueBoxDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ValueBoxDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ValueBoxDef_Default_Proxy_Factory (void);
+  
+  virtual ValueBoxDef_ptr create_proxy (
+      ValueBoxDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ValueBoxDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ValueBoxDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ValueBoxDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ValueBoxDef_ptr create_proxy (
+      ValueBoxDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ValueBoxDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ValueBoxDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ValueBoxDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ValueBoxDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ValueBoxDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_ValueBoxDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ValueBoxDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ValueBoxDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, ValueBoxDef)
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_OperationDef_ptr _ptr_type;
-    typedef CORBA_OperationDef_var _var_type;
-  #endif /* __GNUC__ */
+    TAO_IR_ValueBoxDef_Smart_Proxy_Base (::IR::ValueBoxDef_ptr proxy);
+    ~TAO_IR_ValueBoxDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::IDLType_ptr original_type_def (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void original_type_def (
+      IR::IDLType_ptr original_type_def,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::ValueBoxDef_var base_proxy_;
+};
 
-    // the static operations
-    static CORBA_OperationDef_ptr _duplicate (CORBA_OperationDef_ptr obj);
-    static CORBA_OperationDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_OperationDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_OperationDef_ptr _nil (void)
-      {
-        return (CORBA::OperationDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA::TypeCode_ptr result (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_IDLType_ptr result_def (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueBoxDef;
 
-    virtual void result_def (
-        CORBA_IDLType_ptr result_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_ParDescriptionSeq * params (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_PROVIDESDEF___PTR_CH_)
+#define _IR_PROVIDESDEF___PTR_CH_
 
-    virtual void params (
-        const CORBA_ParDescriptionSeq & params,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+class ProvidesDef;
+typedef ProvidesDef *ProvidesDef_ptr;
 
-    virtual CORBA::OperationMode mode (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual void mode (
-        CORBA::OperationMode mode,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_ContextIdSeq * contexts (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_PROVIDESDEF___VAR_CH_)
+#define _IR_PROVIDESDEF___VAR_CH_
+
+class TAO_Export ProvidesDef_var
+{
+public:
+  ProvidesDef_var (void); // default constructor
+  ProvidesDef_var (ProvidesDef_ptr);
+  ProvidesDef_var (const ProvidesDef_var &); // copy constructor
+  ~ProvidesDef_var (void); // destructor
+  
+  ProvidesDef_var &operator= (ProvidesDef_ptr);
+  ProvidesDef_var &operator= (const ProvidesDef_var &);
+  ProvidesDef_ptr operator-> (void) const;
+  
+  operator const ProvidesDef_ptr &() const;
+  operator ProvidesDef_ptr &();
+  // in, inout, out, _retn 
+  ProvidesDef_ptr in (void) const;
+  ProvidesDef_ptr &inout (void);
+  ProvidesDef_ptr &out (void);
+  ProvidesDef_ptr _retn (void);
+  ProvidesDef_ptr ptr (void) const;
+
+private:
+  ProvidesDef_ptr ptr_;
+};
 
-    virtual void contexts (
-        const CORBA_ContextIdSeq & contexts,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA_ExceptionDefSeq * exceptions (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual void exceptions (
-        const CORBA_ExceptionDefSeq & exceptions,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+#if !defined (_IR_PROVIDESDEF___OUT_CH_)
+#define _IR_PROVIDESDEF___OUT_CH_
 
-  protected:
-    CORBA_OperationDef (void);
-    CORBA_OperationDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_OperationDef (void);
-  private:
-    CORBA_OperationDef (const CORBA_OperationDef &);
-    void operator= (const CORBA_OperationDef &);
-  };
+class TAO_Export ProvidesDef_out
+{
+public:
+  ProvidesDef_out (ProvidesDef_ptr &);
+  ProvidesDef_out (ProvidesDef_var &);
+  ProvidesDef_out (const ProvidesDef_out &);
+  ProvidesDef_out &operator= (const ProvidesDef_out &);
+  ProvidesDef_out &operator= (const ProvidesDef_var &);
+  ProvidesDef_out &operator= (ProvidesDef_ptr);
+  operator ProvidesDef_ptr &();
+  ProvidesDef_ptr &ptr (void);
+  ProvidesDef_ptr operator-> (void);
+  
+private:
+  ProvidesDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-  struct  CORBA_OperationDescription
-  {
-    static void _tao_any_destructor (void*);
 
-    TAO_String_Manager name;
-    TAO_String_Manager id;
-    TAO_String_Manager defined_in;
-    TAO_String_Manager version;
-    CORBA::TypeCode_var result;
-    CORBA::OperationMode mode;
-    CORBA_ContextIdSeq contexts;
-    CORBA_ParDescriptionSeq parameters;
-    CORBA_ExcDescriptionSeq exceptions;
+#if !defined (_IR_PROVIDESDEF_CH_)
+#define _IR_PROVIDESDEF_CH_
+
+class TAO_Export ProvidesDef: public virtual Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ProvidesDef_ptr _ptr_type;
+  typedef ProvidesDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ProvidesDef_ptr _duplicate (ProvidesDef_ptr obj);
+  static ProvidesDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ProvidesDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ProvidesDef_ptr _nil (void)
+    {
+      return (ProvidesDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::InterfaceDef_ptr interface_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  ProvidesDef (void);
+  ProvidesDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ProvidesDef (void);
+private:
+  ProvidesDef (const ProvidesDef &);
+  void operator= (const ProvidesDef &);
+};
+
+class TAO_IR_ProvidesDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ProvidesDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ProvidesDef_Default_Proxy_Factory (void);
+  
+  virtual ProvidesDef_ptr create_proxy (
+      ProvidesDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ProvidesDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ProvidesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ProvidesDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ProvidesDef_ptr create_proxy (
+      ProvidesDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ProvidesDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ProvidesDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ProvidesDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ProvidesDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ProvidesDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
-  class TAO_Export CORBA_OperationDescription_var
+  typedef ACE_Singleton<TAO_IR_ProvidesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ProvidesDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ProvidesDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, ProvidesDef)
   {
   public:
-    CORBA_OperationDescription_var (void); // default constructor
-    CORBA_OperationDescription_var (CORBA_OperationDescription *);
-    CORBA_OperationDescription_var (const CORBA_OperationDescription_var &); // copy constructor
-    ~CORBA_OperationDescription_var (void); // destructor
-
-    CORBA_OperationDescription_var &operator= (CORBA_OperationDescription *);
-    CORBA_OperationDescription_var &operator= (const CORBA_OperationDescription_var &);
-    CORBA_OperationDescription *operator-> (void);
-    const CORBA_OperationDescription *operator-> (void) const;
-
-    operator const CORBA_OperationDescription &() const;
-    operator CORBA_OperationDescription &();
-    operator CORBA_OperationDescription &() const;
-    // in, inout, out, _retn
-    const CORBA_OperationDescription &in (void) const;
-    CORBA_OperationDescription &inout (void);
-    CORBA_OperationDescription *&out (void);
-    CORBA_OperationDescription *_retn (void);
-    CORBA_OperationDescription *ptr (void) const;
+    TAO_IR_ProvidesDef_Smart_Proxy_Base (::IR::ProvidesDef_ptr proxy);
+    ~TAO_IR_ProvidesDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::InterfaceDef_ptr interface_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::ProvidesDef_var base_proxy_;
+};
 
-  private:
-    CORBA_OperationDescription *ptr_;
+
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDef;
+
+struct ProvidesDescription;
+class ProvidesDescription_var;
+
+struct TAO_Export ProvidesDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ProvidesDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  TAO_Object_Field_T<ACE_NESTED_CLASS (IR, InterfaceDef), ACE_NESTED_CLASS (IR, InterfaceDef_var)> interface_type;
+};
+
+class TAO_Export ProvidesDescription_var
+{
+public:
+  ProvidesDescription_var (void); // default constructor
+  ProvidesDescription_var (ProvidesDescription *);
+  ProvidesDescription_var (const ProvidesDescription_var &); // copy constructor
+  ~ProvidesDescription_var (void); // destructor
+  
+  ProvidesDescription_var &operator= (ProvidesDescription *);
+  ProvidesDescription_var &operator= (const ProvidesDescription_var &);
+  ProvidesDescription *operator-> (void);
+  const ProvidesDescription *operator-> (void) const;
+  
+  operator const ProvidesDescription &() const;
+  operator ProvidesDescription &();
+  operator ProvidesDescription &() const;
+  operator ProvidesDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const ProvidesDescription &in (void) const;
+  ProvidesDescription &inout (void);
+  ProvidesDescription *&out (void);
+  ProvidesDescription *_retn (void);
+  ProvidesDescription *ptr (void) const;
+
+private:
+  ProvidesDescription *ptr_;
+};
+
+class TAO_Export ProvidesDescription_out
+{
+public:
+  ProvidesDescription_out (ProvidesDescription *&);
+  ProvidesDescription_out (ProvidesDescription_var &);
+  ProvidesDescription_out (const ProvidesDescription_out &);
+  ProvidesDescription_out &operator= (const ProvidesDescription_out &);
+  ProvidesDescription_out &operator= (ProvidesDescription *);
+  operator ProvidesDescription *&();
+  ProvidesDescription *&ptr (void);
+  ProvidesDescription *operator-> (void);
+  
+private:
+  ProvidesDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ProvidesDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDescription;
+
+
+#if !defined (_IR_USESDEF___PTR_CH_)
+#define _IR_USESDEF___PTR_CH_
+
+class UsesDef;
+typedef UsesDef *UsesDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___VAR_CH_)
+#define _IR_USESDEF___VAR_CH_
+
+class TAO_Export UsesDef_var
+{
+public:
+  UsesDef_var (void); // default constructor
+  UsesDef_var (UsesDef_ptr);
+  UsesDef_var (const UsesDef_var &); // copy constructor
+  ~UsesDef_var (void); // destructor
+  
+  UsesDef_var &operator= (UsesDef_ptr);
+  UsesDef_var &operator= (const UsesDef_var &);
+  UsesDef_ptr operator-> (void) const;
+  
+  operator const UsesDef_ptr &() const;
+  operator UsesDef_ptr &();
+  // in, inout, out, _retn 
+  UsesDef_ptr in (void) const;
+  UsesDef_ptr &inout (void);
+  UsesDef_ptr &out (void);
+  UsesDef_ptr _retn (void);
+  UsesDef_ptr ptr (void) const;
+
+private:
+  UsesDef_ptr ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___OUT_CH_)
+#define _IR_USESDEF___OUT_CH_
+
+class TAO_Export UsesDef_out
+{
+public:
+  UsesDef_out (UsesDef_ptr &);
+  UsesDef_out (UsesDef_var &);
+  UsesDef_out (const UsesDef_out &);
+  UsesDef_out &operator= (const UsesDef_out &);
+  UsesDef_out &operator= (const UsesDef_var &);
+  UsesDef_out &operator= (UsesDef_ptr);
+  operator UsesDef_ptr &();
+  UsesDef_ptr &ptr (void);
+  UsesDef_ptr operator-> (void);
+  
+private:
+  UsesDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF_CH_)
+#define _IR_USESDEF_CH_
+
+class TAO_Export UsesDef: public virtual Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UsesDef_ptr _ptr_type;
+  typedef UsesDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static UsesDef_ptr _duplicate (UsesDef_ptr obj);
+  static UsesDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static UsesDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static UsesDef_ptr _nil (void)
+    {
+      return (UsesDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::InterfaceDef_ptr interface_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_multiple (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  UsesDef (void);
+  UsesDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~UsesDef (void);
+private:
+  UsesDef (const UsesDef &);
+  void operator= (const UsesDef &);
+};
+
+class TAO_IR_UsesDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_UsesDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_UsesDef_Default_Proxy_Factory (void);
+  
+  virtual UsesDef_ptr create_proxy (
+      UsesDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_UsesDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_UsesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_UsesDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  UsesDef_ptr create_proxy (
+      UsesDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_UsesDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_UsesDef_Proxy_Factory_Adapter (void);
+  TAO_IR_UsesDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_UsesDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_UsesDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
-  class TAO_Export CORBA_OperationDescription_out
+  typedef ACE_Singleton<TAO_IR_UsesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_UsesDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_UsesDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, UsesDef)
   {
   public:
-    CORBA_OperationDescription_out (CORBA_OperationDescription *&);
-    CORBA_OperationDescription_out (CORBA_OperationDescription_var &);
-    CORBA_OperationDescription_out (const CORBA_OperationDescription_out &);
-    CORBA_OperationDescription_out &operator= (const CORBA_OperationDescription_out &);
-    CORBA_OperationDescription_out &operator= (CORBA_OperationDescription *);
-    operator CORBA_OperationDescription *&();
-    CORBA_OperationDescription *&ptr (void);
-    CORBA_OperationDescription *operator-> (void);
+    TAO_IR_UsesDef_Smart_Proxy_Base (::IR::UsesDef_ptr proxy);
+    ~TAO_IR_UsesDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::InterfaceDef_ptr interface_type (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_multiple (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::UsesDef_var base_proxy_;
+};
 
-  private:
-    CORBA_OperationDescription *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_OperationDescription_var &);
-  };
 
+#endif /* end #if !defined */
 
-#if !defined (_CORBA_REPOSITORYIDSEQ_CH_)
-#define _CORBA_REPOSITORYIDSEQ_CH_
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDef;
+
+struct UsesDescription;
+class UsesDescription_var;
+
+struct TAO_Export UsesDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UsesDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  TAO_Object_Field_T<ACE_NESTED_CLASS (IR, InterfaceDef), ACE_NESTED_CLASS (IR, InterfaceDef_var)> interface_type;
+  CORBA::Boolean is_multiple;
+};
+
+class TAO_Export UsesDescription_var
+{
+public:
+  UsesDescription_var (void); // default constructor
+  UsesDescription_var (UsesDescription *);
+  UsesDescription_var (const UsesDescription_var &); // copy constructor
+  ~UsesDescription_var (void); // destructor
+  
+  UsesDescription_var &operator= (UsesDescription *);
+  UsesDescription_var &operator= (const UsesDescription_var &);
+  UsesDescription *operator-> (void);
+  const UsesDescription *operator-> (void) const;
+  
+  operator const UsesDescription &() const;
+  operator UsesDescription &();
+  operator UsesDescription &() const;
+  operator UsesDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const UsesDescription &in (void) const;
+  UsesDescription &inout (void);
+  UsesDescription *&out (void);
+  UsesDescription *_retn (void);
+  UsesDescription *ptr (void) const;
+
+private:
+  UsesDescription *ptr_;
+};
+
+class TAO_Export UsesDescription_out
+{
+public:
+  UsesDescription_out (UsesDescription *&);
+  UsesDescription_out (UsesDescription_var &);
+  UsesDescription_out (const UsesDescription_out &);
+  UsesDescription_out &operator= (const UsesDescription_out &);
+  UsesDescription_out &operator= (UsesDescription *);
+  operator UsesDescription *&();
+  UsesDescription *&ptr (void);
+  UsesDescription *operator-> (void);
+  
+private:
+  UsesDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const UsesDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDescription;
 
-  // *************************************************************
-  // RepositoryIdSeq
-  // *************************************************************
 
-  class TAO_Export CORBA_RepositoryIdSeq : public
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    TAO_Unbounded_String_Sequence
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_String_Sequence
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_ProvidesDescSeq : public TAO_Unbounded_Base_Sequence
   {
   public:
-    CORBA_RepositoryIdSeq (void); // default ctor
-    CORBA_RepositoryIdSeq (CORBA::ULong max); // uses max size
-    CORBA_RepositoryIdSeq (
-      CORBA::ULong max,
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum,
       CORBA::ULong length,
-      char * *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_RepositoryIdSeq (const CORBA_RepositoryIdSeq &); // copy ctor
-    ~CORBA_RepositoryIdSeq (void); // dtor
-
-    static void _tao_any_destructor (void*);
+      ProvidesDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &operator= (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void); // Dtor.
+    // = Accessors.
+    ProvidesDescription &operator[] (CORBA::ULong i);
+    const ProvidesDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static ProvidesDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (ProvidesDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    ProvidesDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const ProvidesDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      ProvidesDescription *data,
+      CORBA::Boolean release);
   };
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_REPOSITORYIDSEQ___VAR_CH_)
-#define _CORBA_REPOSITORYIDSEQ___VAR_CH_
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDESCSEQ_CH_)
+#define _IR_PROVIDESDESCSEQ_CH_
+
+class ProvidesDescSeq;
+class ProvidesDescSeq_var;
 
 // *************************************************************
-  // class CORBA::RepositoryIdSeq_var
-  // *************************************************************
+// ProvidesDescSeq
+// *************************************************************
 
-  class TAO_Export CORBA_RepositoryIdSeq_var
-  {
-  public:
-    CORBA_RepositoryIdSeq_var (void); // default constructor
-    CORBA_RepositoryIdSeq_var (CORBA_RepositoryIdSeq *);
-    CORBA_RepositoryIdSeq_var (const CORBA_RepositoryIdSeq_var &); // copy constructor
-    ~CORBA_RepositoryIdSeq_var (void); // destructor
-
-    CORBA_RepositoryIdSeq_var &operator= (CORBA_RepositoryIdSeq *);
-    CORBA_RepositoryIdSeq_var &operator= (const CORBA_RepositoryIdSeq_var &);
-    CORBA_RepositoryIdSeq *operator-> (void);
-    const CORBA_RepositoryIdSeq *operator-> (void) const;
-
-    operator const CORBA_RepositoryIdSeq &() const;
-    operator CORBA_RepositoryIdSeq &();
-    operator CORBA_RepositoryIdSeq &() const;
-    TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_RepositoryIdSeq &in (void) const;
-    CORBA_RepositoryIdSeq &inout (void);
-    CORBA_RepositoryIdSeq *&out (void);
-    CORBA_RepositoryIdSeq *_retn (void);
-    CORBA_RepositoryIdSeq *ptr (void) const;
+class TAO_Export ProvidesDescSeq : public 
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  _TAO_Unbounded_Sequence_IR_ProvidesDescSeq
+#else /* TAO_USE_SEQUENCE_TEMPLATES */
+  TAO_Unbounded_Sequence<ProvidesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  ProvidesDescSeq (void); // default ctor
+  ProvidesDescSeq (CORBA::ULong max); // uses max size
+  ProvidesDescSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    ProvidesDescription *buffer, 
+    CORBA::Boolean release=0
+  );
+  ProvidesDescSeq (const ProvidesDescSeq &); // copy ctor
+  ~ProvidesDescSeq (void);
+  static void _tao_any_destructor (void*);
 
-  private:
-    CORBA_RepositoryIdSeq *ptr_;
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ProvidesDescSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_REPOSITORYIDSEQ___OUT_CH_)
-#define _CORBA_REPOSITORYIDSEQ___OUT_CH_
+#if !defined (_IR_PROVIDESDESCSEQ___VAR_CH_)
+#define _IR_PROVIDESDESCSEQ___VAR_CH_
 
-  class TAO_Export CORBA_RepositoryIdSeq_out
-  {
-  public:
-    CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq *&);
-    CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq_var &);
-    CORBA_RepositoryIdSeq_out (const CORBA_RepositoryIdSeq_out &);
-    CORBA_RepositoryIdSeq_out &operator= (const CORBA_RepositoryIdSeq_out &);
-    CORBA_RepositoryIdSeq_out &operator= (CORBA_RepositoryIdSeq *);
-    operator CORBA_RepositoryIdSeq *&();
-    CORBA_RepositoryIdSeq *&ptr (void);
-    CORBA_RepositoryIdSeq *operator-> (void);
-    TAO_SeqElem_String_Manager operator[] (CORBA::ULong index);
+// *************************************************************
+// class IR::ProvidesDescSeq_var
+// *************************************************************
 
-  private:
-    CORBA_RepositoryIdSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_RepositoryIdSeq_var &);
-  };
+class TAO_Export ProvidesDescSeq_var
+{
+public:
+  ProvidesDescSeq_var (void); // default constructor
+  ProvidesDescSeq_var (ProvidesDescSeq *);
+  ProvidesDescSeq_var (const ProvidesDescSeq_var &); // copy constructor
+  ~ProvidesDescSeq_var (void); // destructor
+  
+  ProvidesDescSeq_var &operator= (ProvidesDescSeq *);
+  ProvidesDescSeq_var &operator= (const ProvidesDescSeq_var &);
+  ProvidesDescSeq *operator-> (void);
+  const ProvidesDescSeq *operator-> (void) const;
+  
+  operator const ProvidesDescSeq &() const;
+  operator ProvidesDescSeq &();
+  operator ProvidesDescSeq &() const;
+  operator ProvidesDescSeq *&(); // variable-size base types only
+  
+  ProvidesDescription &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const ProvidesDescSeq &in (void) const;
+  ProvidesDescSeq &inout (void);
+  ProvidesDescSeq *&out (void);
+  ProvidesDescSeq *_retn (void);
+  ProvidesDescSeq *ptr (void) const;
+
+private:
+  ProvidesDescSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+#if !defined (_IR_PROVIDESDESCSEQ___OUT_CH_)
+#define _IR_PROVIDESDESCSEQ___OUT_CH_
+
+class TAO_Export ProvidesDescSeq_out
+{
+public:
+  ProvidesDescSeq_out (ProvidesDescSeq *&);
+  ProvidesDescSeq_out (ProvidesDescSeq_var &);
+  ProvidesDescSeq_out (const ProvidesDescSeq_out &);
+  ProvidesDescSeq_out &operator= (const ProvidesDescSeq_out &);
+  ProvidesDescSeq_out &operator= (ProvidesDescSeq *);
+  operator ProvidesDescSeq *&();
+  ProvidesDescSeq *&ptr (void);
+  ProvidesDescSeq *operator-> (void);
+  ProvidesDescription &operator[] (CORBA::ULong index);
+  
+private:
+  ProvidesDescSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ProvidesDescSeq_var &);
+};
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CH_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CH_
 
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+#endif /* end #if !defined */
 
-      _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void); // Default constructor.
-      _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_OperationDescription *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs);
-      _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs);
-      virtual ~_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void); // Dtor.
-      // = Accessors.
-      CORBA_OperationDescription &operator[] (CORBA::ULong i);
-      const CORBA_OperationDescription &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static CORBA_OperationDescription *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA_OperationDescription *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ProvidesDescSeq;
 
-      CORBA_OperationDescription *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_OperationDescription *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        CORBA_OperationDescription *data,
-        CORBA::Boolean release);
-    };
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CH_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CH_
+
+  class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_IR_UsesDescSeq : public TAO_Unbounded_Base_Sequence
+  {
+  public:
+    // = Initialization and termination methods.
+    
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq (void); // Default constructor.
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum); 
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum,
+      CORBA::ULong length,
+      UsesDescription *data,
+      CORBA::Boolean release = 0);
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs);
+    _TAO_Unbounded_Sequence_IR_UsesDescSeq &operator= (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs);
+    virtual ~_TAO_Unbounded_Sequence_IR_UsesDescSeq (void); // Dtor.
+    // = Accessors.
+    UsesDescription &operator[] (CORBA::ULong i);
+    const UsesDescription &operator[] (CORBA::ULong i) const;
+    // = Static operations.
+    static UsesDescription *allocbuf (CORBA::ULong size);
+    static void freebuf (UsesDescription *buffer);
+    virtual void _allocate_buffer (CORBA::ULong length);
+    virtual void _deallocate_buffer (void);
+    // Implement the TAO_Base_Sequence methods (see Sequence.h)
+    
+    UsesDescription *get_buffer (CORBA::Boolean orphan = 0);
+    const UsesDescription *get_buffer (void) const;
+    void replace (CORBA::ULong max,
+      CORBA::ULong length,
+      UsesDescription *data,
+      CORBA::Boolean release);
+  };
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_OPDESCRIPTIONSEQ_CH_)
-#define _CORBA_OPDESCRIPTIONSEQ_CH_
+#if !defined (_IR_USESDESCSEQ_CH_)
+#define _IR_USESDESCSEQ_CH_
 
-  // *************************************************************
-  // OpDescriptionSeq
-  // *************************************************************
+class UsesDescSeq;
+class UsesDescSeq_var;
 
-  class TAO_Export CORBA_OpDescriptionSeq : public
+// *************************************************************
+// UsesDescSeq
+// *************************************************************
+
+class TAO_Export UsesDescSeq : public 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq
+  _TAO_Unbounded_Sequence_IR_UsesDescSeq
 #else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA_OperationDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-  {
-  public:
-    CORBA_OpDescriptionSeq (void); // default ctor
-    CORBA_OpDescriptionSeq (CORBA::ULong max); // uses max size
-    CORBA_OpDescriptionSeq (
-      CORBA::ULong max,
-      CORBA::ULong length,
-      CORBA_OperationDescription *buffer,
-      CORBA::Boolean release=0
-    );
-    CORBA_OpDescriptionSeq (const CORBA_OpDescriptionSeq &); // copy ctor
-    ~CORBA_OpDescriptionSeq (void); // dtor
+  TAO_Unbounded_Sequence<UsesDescription>
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+{
+public:
+  UsesDescSeq (void); // default ctor
+  UsesDescSeq (CORBA::ULong max); // uses max size
+  UsesDescSeq (
+    CORBA::ULong max, 
+    CORBA::ULong length, 
+    UsesDescription *buffer, 
+    CORBA::Boolean release=0
+  );
+  UsesDescSeq (const UsesDescSeq &); // copy ctor
+  ~UsesDescSeq (void);
+  static void _tao_any_destructor (void*);
 
-    static void _tao_any_destructor (void*);
-  };
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef UsesDescSeq_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+};
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_OPDESCRIPTIONSEQ___VAR_CH_)
-#define _CORBA_OPDESCRIPTIONSEQ___VAR_CH_
+#if !defined (_IR_USESDESCSEQ___VAR_CH_)
+#define _IR_USESDESCSEQ___VAR_CH_
 
 // *************************************************************
-  // class CORBA::OpDescriptionSeq_var
-  // *************************************************************
+// class IR::UsesDescSeq_var
+// *************************************************************
 
-  class TAO_Export CORBA_OpDescriptionSeq_var
-  {
-  public:
-    CORBA_OpDescriptionSeq_var (void); // default constructor
-    CORBA_OpDescriptionSeq_var (CORBA_OpDescriptionSeq *);
-    CORBA_OpDescriptionSeq_var (const CORBA_OpDescriptionSeq_var &); // copy constructor
-    ~CORBA_OpDescriptionSeq_var (void); // destructor
-
-    CORBA_OpDescriptionSeq_var &operator= (CORBA_OpDescriptionSeq *);
-    CORBA_OpDescriptionSeq_var &operator= (const CORBA_OpDescriptionSeq_var &);
-    CORBA_OpDescriptionSeq *operator-> (void);
-    const CORBA_OpDescriptionSeq *operator-> (void) const;
-
-    operator const CORBA_OpDescriptionSeq &() const;
-    operator CORBA_OpDescriptionSeq &();
-    operator CORBA_OpDescriptionSeq &() const;
-    CORBA_OperationDescription &operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_OpDescriptionSeq &in (void) const;
-    CORBA_OpDescriptionSeq &inout (void);
-    CORBA_OpDescriptionSeq *&out (void);
-    CORBA_OpDescriptionSeq *_retn (void);
-    CORBA_OpDescriptionSeq *ptr (void) const;
-
-  private:
-    CORBA_OpDescriptionSeq *ptr_;
-  };
+class TAO_Export UsesDescSeq_var
+{
+public:
+  UsesDescSeq_var (void); // default constructor
+  UsesDescSeq_var (UsesDescSeq *);
+  UsesDescSeq_var (const UsesDescSeq_var &); // copy constructor
+  ~UsesDescSeq_var (void); // destructor
+  
+  UsesDescSeq_var &operator= (UsesDescSeq *);
+  UsesDescSeq_var &operator= (const UsesDescSeq_var &);
+  UsesDescSeq *operator-> (void);
+  const UsesDescSeq *operator-> (void) const;
+  
+  operator const UsesDescSeq &() const;
+  operator UsesDescSeq &();
+  operator UsesDescSeq &() const;
+  operator UsesDescSeq *&(); // variable-size base types only
+  
+  UsesDescription &operator[] (CORBA::ULong index);
+  // in, inout, out, _retn 
+  const UsesDescSeq &in (void) const;
+  UsesDescSeq &inout (void);
+  UsesDescSeq *&out (void);
+  UsesDescSeq *_retn (void);
+  UsesDescSeq *ptr (void) const;
+
+private:
+  UsesDescSeq *ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_OPDESCRIPTIONSEQ___OUT_CH_)
-#define _CORBA_OPDESCRIPTIONSEQ___OUT_CH_
+#if !defined (_IR_USESDESCSEQ___OUT_CH_)
+#define _IR_USESDESCSEQ___OUT_CH_
+
+class TAO_Export UsesDescSeq_out
+{
+public:
+  UsesDescSeq_out (UsesDescSeq *&);
+  UsesDescSeq_out (UsesDescSeq_var &);
+  UsesDescSeq_out (const UsesDescSeq_out &);
+  UsesDescSeq_out &operator= (const UsesDescSeq_out &);
+  UsesDescSeq_out &operator= (UsesDescSeq *);
+  operator UsesDescSeq *&();
+  UsesDescSeq *&ptr (void);
+  UsesDescSeq *operator-> (void);
+  UsesDescription &operator[] (CORBA::ULong index);
+  
+private:
+  UsesDescSeq *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const UsesDescSeq_var &);
+};
 
-  class TAO_Export CORBA_OpDescriptionSeq_out
-  {
-  public:
-    CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq *&);
-    CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq_var &);
-    CORBA_OpDescriptionSeq_out (const CORBA_OpDescriptionSeq_out &);
-    CORBA_OpDescriptionSeq_out &operator= (const CORBA_OpDescriptionSeq_out &);
-    CORBA_OpDescriptionSeq_out &operator= (CORBA_OpDescriptionSeq *);
-    operator CORBA_OpDescriptionSeq *&();
-    CORBA_OpDescriptionSeq *&ptr (void);
-    CORBA_OpDescriptionSeq *operator-> (void);
-    CORBA_OperationDescription &operator[] (CORBA::ULong index);
 
-  private:
-    CORBA_OpDescriptionSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_OpDescriptionSeq_var &);
-  };
+#endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UsesDescSeq;
+
+
+#if !defined (_IR_EVENTDEF___PTR_CH_)
+#define _IR_EVENTDEF___PTR_CH_
+
+class EventDef;
+typedef EventDef *EventDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+#if !defined (_IR_EVENTDEF___VAR_CH_)
+#define _IR_EVENTDEF___VAR_CH_
+
+class TAO_Export EventDef_var
+{
+public:
+  EventDef_var (void); // default constructor
+  EventDef_var (EventDef_ptr);
+  EventDef_var (const EventDef_var &); // copy constructor
+  ~EventDef_var (void); // destructor
+  
+  EventDef_var &operator= (EventDef_ptr);
+  EventDef_var &operator= (const EventDef_var &);
+  EventDef_ptr operator-> (void) const;
+  
+  operator const EventDef_ptr &() const;
+  operator EventDef_ptr &();
+  // in, inout, out, _retn 
+  EventDef_ptr in (void) const;
+  EventDef_ptr &inout (void);
+  EventDef_ptr &out (void);
+  EventDef_ptr _retn (void);
+  EventDef_ptr ptr (void) const;
+
+private:
+  EventDef_ptr ptr_;
+};
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CH_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CH_
 
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+#endif /* end #if !defined */
 
-      _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void); // Default constructor.
-      _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_AttributeDescription *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs);
-      _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs);
-      virtual ~_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void); // Dtor.
-      // = Accessors.
-      CORBA_AttributeDescription &operator[] (CORBA::ULong i);
-      const CORBA_AttributeDescription &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static CORBA_AttributeDescription *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA_AttributeDescription *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
 
-      CORBA_AttributeDescription *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_AttributeDescription *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        CORBA_AttributeDescription *data,
-        CORBA::Boolean release);
-    };
+#if !defined (_IR_EVENTDEF___OUT_CH_)
+#define _IR_EVENTDEF___OUT_CH_
+
+class TAO_Export EventDef_out
+{
+public:
+  EventDef_out (EventDef_ptr &);
+  EventDef_out (EventDef_var &);
+  EventDef_out (const EventDef_out &);
+  EventDef_out &operator= (const EventDef_out &);
+  EventDef_out &operator= (const EventDef_var &);
+  EventDef_out &operator= (EventDef_ptr);
+  operator EventDef_ptr &();
+  EventDef_ptr &ptr (void);
+  EventDef_ptr operator-> (void);
+  
+private:
+  EventDef_ptr &ptr_;
+};
+
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_EVENTDEF_CH_)
+#define _IR_EVENTDEF_CH_
 
-#if !defined (_CORBA_ATTRDESCRIPTIONSEQ_CH_)
-#define _CORBA_ATTRDESCRIPTIONSEQ_CH_
+class TAO_Export EventDef: public virtual Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef EventDef_ptr _ptr_type;
+  typedef EventDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  // *************************************************************
-  // AttrDescriptionSeq
-  // *************************************************************
+  // the static operations
+  static EventDef_ptr _duplicate (EventDef_ptr obj);
+  static EventDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static EventDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static EventDef_ptr _nil (void)
+    {
+      return (EventDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean is_a (
+      const char * event_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueDef_ptr event (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
 
-  class TAO_Export CORBA_AttrDescriptionSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA_AttributeDescription>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-  {
-  public:
-    CORBA_AttrDescriptionSeq (void); // default ctor
-    CORBA_AttrDescriptionSeq (CORBA::ULong max); // uses max size
-    CORBA_AttrDescriptionSeq (
-      CORBA::ULong max,
-      CORBA::ULong length,
-      CORBA_AttributeDescription *buffer,
-      CORBA::Boolean release=0
+protected:
+  EventDef (void);
+  EventDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~EventDef (void);
+private:
+  EventDef (const EventDef &);
+  void operator= (const EventDef &);
+};
+
+class TAO_IR_EventDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_EventDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_EventDef_Default_Proxy_Factory (void);
+  
+  virtual EventDef_ptr create_proxy (
+      EventDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_EventDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_EventDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_EventDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  EventDef_ptr create_proxy (
+      EventDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
     );
-    CORBA_AttrDescriptionSeq (const CORBA_AttrDescriptionSeq &); // copy ctor
-    ~CORBA_AttrDescriptionSeq (void); // dtor
 
-    static void _tao_any_destructor (void*);
+protected:
+  TAO_IR_EventDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_EventDef_Proxy_Factory_Adapter (void);
+  TAO_IR_EventDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_EventDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_EventDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
+  typedef ACE_Singleton<TAO_IR_EventDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_EventDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_EventDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, EventDef)
+  {
+  public:
+    TAO_IR_EventDef_Smart_Proxy_Base (::IR::EventDef_ptr proxy);
+    ~TAO_IR_EventDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::Boolean is_a (
+      const char * event_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueDef_ptr event (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::EventDef_var base_proxy_;
+};
+
+
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EventDef;
+
+struct EventDescription;
+class EventDescription_var;
+
+struct TAO_Export EventDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef EventDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  TAO_Object_Field_T<ACE_NESTED_CLASS (IR, ValueDef), ACE_NESTED_CLASS (IR, ValueDef_var)> value;
+};
+
+class TAO_Export EventDescription_var
+{
+public:
+  EventDescription_var (void); // default constructor
+  EventDescription_var (EventDescription *);
+  EventDescription_var (const EventDescription_var &); // copy constructor
+  ~EventDescription_var (void); // destructor
+  
+  EventDescription_var &operator= (EventDescription *);
+  EventDescription_var &operator= (const EventDescription_var &);
+  EventDescription *operator-> (void);
+  const EventDescription *operator-> (void) const;
+  
+  operator const EventDescription &() const;
+  operator EventDescription &();
+  operator EventDescription &() const;
+  operator EventDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const EventDescription &in (void) const;
+  EventDescription &inout (void);
+  EventDescription *&out (void);
+  EventDescription *_retn (void);
+  EventDescription *ptr (void) const;
+
+private:
+  EventDescription *ptr_;
+};
+
+class TAO_Export EventDescription_out
+{
+public:
+  EventDescription_out (EventDescription *&);
+  EventDescription_out (EventDescription_var &);
+  EventDescription_out (const EventDescription_out &);
+  EventDescription_out &operator= (const EventDescription_out &);
+  EventDescription_out &operator= (EventDescription *);
+  operator EventDescription *&();
+  EventDescription *&ptr (void);
+  EventDescription *operator-> (void);
+  
+private:
+  EventDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const EventDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EventDescription;
+
+
+#if !defined (_IR_EMITSDEF___PTR_CH_)
+#define _IR_EMITSDEF___PTR_CH_
+
+class EmitsDef;
+typedef EmitsDef *EmitsDef_ptr;
 
-#if !defined (_CORBA_ATTRDESCRIPTIONSEQ___VAR_CH_)
-#define _CORBA_ATTRDESCRIPTIONSEQ___VAR_CH_
+#endif /* end #if !defined */
 
-// *************************************************************
-  // class TAO_ExportCORBA::AttrDescriptionSeq_var
-  // *************************************************************
 
-  class TAO_Export CORBA_AttrDescriptionSeq_var
-  {
-  public:
-    CORBA_AttrDescriptionSeq_var (void); // default constructor
-    CORBA_AttrDescriptionSeq_var (CORBA_AttrDescriptionSeq *);
-    CORBA_AttrDescriptionSeq_var (const CORBA_AttrDescriptionSeq_var &); // copy constructor
-    ~CORBA_AttrDescriptionSeq_var (void); // destructor
-
-    CORBA_AttrDescriptionSeq_var &operator= (CORBA_AttrDescriptionSeq *);
-    CORBA_AttrDescriptionSeq_var &operator= (const CORBA_AttrDescriptionSeq_var &);
-    CORBA_AttrDescriptionSeq *operator-> (void);
-    const CORBA_AttrDescriptionSeq *operator-> (void) const;
-
-    operator const CORBA_AttrDescriptionSeq &() const;
-    operator CORBA_AttrDescriptionSeq &();
-    operator CORBA_AttrDescriptionSeq &() const;
-    CORBA_AttributeDescription &operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_AttrDescriptionSeq &in (void) const;
-    CORBA_AttrDescriptionSeq &inout (void);
-    CORBA_AttrDescriptionSeq *&out (void);
-    CORBA_AttrDescriptionSeq *_retn (void);
-    CORBA_AttrDescriptionSeq *ptr (void) const;
+#if !defined (_IR_EMITSDEF___VAR_CH_)
+#define _IR_EMITSDEF___VAR_CH_
+
+class TAO_Export EmitsDef_var
+{
+public:
+  EmitsDef_var (void); // default constructor
+  EmitsDef_var (EmitsDef_ptr);
+  EmitsDef_var (const EmitsDef_var &); // copy constructor
+  ~EmitsDef_var (void); // destructor
+  
+  EmitsDef_var &operator= (EmitsDef_ptr);
+  EmitsDef_var &operator= (const EmitsDef_var &);
+  EmitsDef_ptr operator-> (void) const;
+  
+  operator const EmitsDef_ptr &() const;
+  operator EmitsDef_ptr &();
+  // in, inout, out, _retn 
+  EmitsDef_ptr in (void) const;
+  EmitsDef_ptr &inout (void);
+  EmitsDef_ptr &out (void);
+  EmitsDef_ptr _retn (void);
+  EmitsDef_ptr ptr (void) const;
+
+private:
+  EmitsDef_ptr ptr_;
+};
 
-  private:
-    CORBA_AttrDescriptionSeq *ptr_;
-  };
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EMITSDEF___OUT_CH_)
+#define _IR_EMITSDEF___OUT_CH_
+
+class TAO_Export EmitsDef_out
+{
+public:
+  EmitsDef_out (EmitsDef_ptr &);
+  EmitsDef_out (EmitsDef_var &);
+  EmitsDef_out (const EmitsDef_out &);
+  EmitsDef_out &operator= (const EmitsDef_out &);
+  EmitsDef_out &operator= (const EmitsDef_var &);
+  EmitsDef_out &operator= (EmitsDef_ptr);
+  operator EmitsDef_ptr &();
+  EmitsDef_ptr &ptr (void);
+  EmitsDef_ptr operator-> (void);
+  
+private:
+  EmitsDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ATTRDESCRIPTIONSEQ___OUT_CH_)
-#define _CORBA_ATTRDESCRIPTIONSEQ___OUT_CH_
+#if !defined (_IR_EMITSDEF_CH_)
+#define _IR_EMITSDEF_CH_
+
+class TAO_Export EmitsDef: public virtual EventDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef EmitsDef_ptr _ptr_type;
+  typedef EmitsDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static EmitsDef_ptr _duplicate (EmitsDef_ptr obj);
+  static EmitsDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static EmitsDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static EmitsDef_ptr _nil (void)
+    {
+      return (EmitsDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  EmitsDef (void);
+  EmitsDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~EmitsDef (void);
+private:
+  EmitsDef (const EmitsDef &);
+  void operator= (const EmitsDef &);
+};
+
+class TAO_IR_EmitsDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_EmitsDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_EmitsDef_Default_Proxy_Factory (void);
+  
+  virtual EmitsDef_ptr create_proxy (
+      EmitsDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_EmitsDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_EmitsDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_EmitsDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  EmitsDef_ptr create_proxy (
+      EmitsDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_EmitsDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_EmitsDef_Proxy_Factory_Adapter (void);
+  TAO_IR_EmitsDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_EmitsDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_EmitsDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
 
-  class TAO_Export CORBA_AttrDescriptionSeq_out
+  typedef ACE_Singleton<TAO_IR_EmitsDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_EmitsDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_EmitsDef_Smart_Proxy_Base : public virtual EmitsDef
   {
   public:
-    CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptionSeq *&);
-    CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptionSeq_var &);
-    CORBA_AttrDescriptionSeq_out (const CORBA_AttrDescriptionSeq_out &);
-    CORBA_AttrDescriptionSeq_out &operator= (const CORBA_AttrDescriptionSeq_out &);
-    CORBA_AttrDescriptionSeq_out &operator= (CORBA_AttrDescriptionSeq *);
-    operator CORBA_AttrDescriptionSeq *&();
-    CORBA_AttrDescriptionSeq *&ptr (void);
-    CORBA_AttrDescriptionSeq *operator-> (void);
-    CORBA_AttributeDescription &operator[] (CORBA::ULong index);
+    TAO_IR_EmitsDef_Smart_Proxy_Base (::IR::EmitsDef_ptr proxy);
+    ~TAO_IR_EmitsDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+    private:
+  ::IR::EmitsDef_var base_proxy_;
+};
 
-  private:
-    CORBA_AttrDescriptionSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_AttrDescriptionSeq_var &);
-  };
+
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EmitsDef;
 
 
+#if !defined (_IR_PUBLISHESDEF___PTR_CH_)
+#define _IR_PUBLISHESDEF___PTR_CH_
+
+class PublishesDef;
+typedef PublishesDef *PublishesDef_ptr;
+
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_INTERFACEDEF___VAR_CH_)
-#define _CORBA_INTERFACEDEF___VAR_CH_
+#if !defined (_IR_PUBLISHESDEF___VAR_CH_)
+#define _IR_PUBLISHESDEF___VAR_CH_
+
+class TAO_Export PublishesDef_var
+{
+public:
+  PublishesDef_var (void); // default constructor
+  PublishesDef_var (PublishesDef_ptr);
+  PublishesDef_var (const PublishesDef_var &); // copy constructor
+  ~PublishesDef_var (void); // destructor
+  
+  PublishesDef_var &operator= (PublishesDef_ptr);
+  PublishesDef_var &operator= (const PublishesDef_var &);
+  PublishesDef_ptr operator-> (void) const;
+  
+  operator const PublishesDef_ptr &() const;
+  operator PublishesDef_ptr &();
+  // in, inout, out, _retn 
+  PublishesDef_ptr in (void) const;
+  PublishesDef_ptr &inout (void);
+  PublishesDef_ptr &out (void);
+  PublishesDef_ptr _retn (void);
+  PublishesDef_ptr ptr (void) const;
+
+private:
+  PublishesDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_InterfaceDef_var
-  {
-  public:
-    CORBA_InterfaceDef_var (void); // default constructor
-    CORBA_InterfaceDef_var (CORBA_InterfaceDef_ptr);
-    CORBA_InterfaceDef_var (const CORBA_InterfaceDef_var &); // copy constructor
-    ~CORBA_InterfaceDef_var (void); // destructor
 
-    CORBA_InterfaceDef_var &operator= (CORBA_InterfaceDef_ptr);
-    CORBA_InterfaceDef_var &operator= (const CORBA_InterfaceDef_var &);
-    CORBA_InterfaceDef_ptr operator-> (void) const;
+#endif /* end #if !defined */
 
-    operator const CORBA_InterfaceDef_ptr &() const;
-    operator CORBA_InterfaceDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_InterfaceDef_ptr in (void) const;
-    CORBA_InterfaceDef_ptr &inout (void);
-    CORBA_InterfaceDef_ptr &out (void);
-    CORBA_InterfaceDef_ptr _retn (void);
-    CORBA_InterfaceDef_ptr ptr (void) const;
 
-  private:
-    CORBA_InterfaceDef_ptr ptr_;
-  };
+#if !defined (_IR_PUBLISHESDEF___OUT_CH_)
+#define _IR_PUBLISHESDEF___OUT_CH_
+
+class TAO_Export PublishesDef_out
+{
+public:
+  PublishesDef_out (PublishesDef_ptr &);
+  PublishesDef_out (PublishesDef_var &);
+  PublishesDef_out (const PublishesDef_out &);
+  PublishesDef_out &operator= (const PublishesDef_out &);
+  PublishesDef_out &operator= (const PublishesDef_var &);
+  PublishesDef_out &operator= (PublishesDef_ptr);
+  operator PublishesDef_ptr &();
+  PublishesDef_ptr &ptr (void);
+  PublishesDef_ptr operator-> (void);
+  
+private:
+  PublishesDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_INTERFACEDEF___OUT_CH_)
-#define _CORBA_INTERFACEDEF___OUT_CH_
+#if !defined (_IR_PUBLISHESDEF_CH_)
+#define _IR_PUBLISHESDEF_CH_
+
+class TAO_Export PublishesDef: public virtual EventDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef PublishesDef_ptr _ptr_type;
+  typedef PublishesDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  class TAO_Export CORBA_InterfaceDef_out
+  // the static operations
+  static PublishesDef_ptr _duplicate (PublishesDef_ptr obj);
+  static PublishesDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static PublishesDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static PublishesDef_ptr _nil (void)
+    {
+      return (PublishesDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  PublishesDef (void);
+  PublishesDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~PublishesDef (void);
+private:
+  PublishesDef (const PublishesDef &);
+  void operator= (const PublishesDef &);
+};
+
+class TAO_IR_PublishesDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_PublishesDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_PublishesDef_Default_Proxy_Factory (void);
+  
+  virtual PublishesDef_ptr create_proxy (
+      PublishesDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_PublishesDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_PublishesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_PublishesDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  PublishesDef_ptr create_proxy (
+      PublishesDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_PublishesDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_PublishesDef_Proxy_Factory_Adapter (void);
+  TAO_IR_PublishesDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_PublishesDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_PublishesDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_PublishesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_PublishesDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_PublishesDef_Smart_Proxy_Base : public virtual PublishesDef
   {
   public:
-    CORBA_InterfaceDef_out (CORBA_InterfaceDef_ptr &);
-    CORBA_InterfaceDef_out (CORBA_InterfaceDef_var &);
-    CORBA_InterfaceDef_out (const CORBA_InterfaceDef_out &);
-    CORBA_InterfaceDef_out &operator= (const CORBA_InterfaceDef_out &);
-    CORBA_InterfaceDef_out &operator= (const CORBA_InterfaceDef_var &);
-    CORBA_InterfaceDef_out &operator= (CORBA_InterfaceDef_ptr);
-    operator CORBA_InterfaceDef_ptr &();
-    CORBA_InterfaceDef_ptr &ptr (void);
-    CORBA_InterfaceDef_ptr operator-> (void);
+    TAO_IR_PublishesDef_Smart_Proxy_Base (::IR::PublishesDef_ptr proxy);
+    ~TAO_IR_PublishesDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+    private:
+  ::IR::PublishesDef_var base_proxy_;
+};
 
-  private:
-    CORBA_InterfaceDef_ptr &ptr_;
-  };
 
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PublishesDef;
+
+
+#if !defined (_IR_CONSUMESDEF___PTR_CH_)
+#define _IR_CONSUMESDEF___PTR_CH_
+
+class ConsumesDef;
+typedef ConsumesDef *ConsumesDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_INTERFACEDEF_CH_)
-#define _CORBA_INTERFACEDEF_CH_
+#if !defined (_IR_CONSUMESDEF___VAR_CH_)
+#define _IR_CONSUMESDEF___VAR_CH_
+
+class TAO_Export ConsumesDef_var
+{
+public:
+  ConsumesDef_var (void); // default constructor
+  ConsumesDef_var (ConsumesDef_ptr);
+  ConsumesDef_var (const ConsumesDef_var &); // copy constructor
+  ~ConsumesDef_var (void); // destructor
+  
+  ConsumesDef_var &operator= (ConsumesDef_ptr);
+  ConsumesDef_var &operator= (const ConsumesDef_var &);
+  ConsumesDef_ptr operator-> (void) const;
+  
+  operator const ConsumesDef_ptr &() const;
+  operator ConsumesDef_ptr &();
+  // in, inout, out, _retn 
+  ConsumesDef_ptr in (void) const;
+  ConsumesDef_ptr &inout (void);
+  ConsumesDef_ptr &out (void);
+  ConsumesDef_ptr _retn (void);
+  ConsumesDef_ptr ptr (void) const;
+
+private:
+  ConsumesDef_ptr ptr_;
+};
 
-class TAO_Export CORBA_InterfaceDef: public virtual CORBA_Container, public virtual CORBA_Contained, public virtual CORBA_IDLType
-  {
-  public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_InterfaceDef_ptr _ptr_type;
-    typedef CORBA_InterfaceDef_var _var_type;
-  #endif /* __GNUC__ */
 
-    // the static operations
-    static CORBA_InterfaceDef_ptr _duplicate (CORBA_InterfaceDef_ptr obj);
-    static CORBA_InterfaceDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_InterfaceDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_InterfaceDef_ptr _nil (void)
-      {
-        return (CORBA::InterfaceDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
+#endif /* end #if !defined */
 
-    virtual CORBA_InterfaceDefSeq * base_interfaces (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual void base_interfaces (
-        const CORBA_InterfaceDefSeq & base_interfaces,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_CONSUMESDEF___OUT_CH_)
+#define _IR_CONSUMESDEF___OUT_CH_
 
-    virtual CORBA::Boolean is_a (
-        const char * interface_id,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+class TAO_Export ConsumesDef_out
+{
+public:
+  ConsumesDef_out (ConsumesDef_ptr &);
+  ConsumesDef_out (ConsumesDef_var &);
+  ConsumesDef_out (const ConsumesDef_out &);
+  ConsumesDef_out &operator= (const ConsumesDef_out &);
+  ConsumesDef_out &operator= (const ConsumesDef_var &);
+  ConsumesDef_out &operator= (ConsumesDef_ptr);
+  operator ConsumesDef_ptr &();
+  ConsumesDef_ptr &ptr (void);
+  ConsumesDef_ptr operator-> (void);
+  
+private:
+  ConsumesDef_ptr &ptr_;
+};
 
-    struct  FullInterfaceDescription
-    {
-      static void _tao_any_destructor (void*);
 
-      TAO_String_Manager name;
-      TAO_String_Manager id;
-      TAO_String_Manager defined_in;
-      TAO_String_Manager version;
-      CORBA_OpDescriptionSeq operations;
-      CORBA_AttrDescriptionSeq attributes;
-      CORBA_RepositoryIdSeq base_interfaces;
-      CORBA::TypeCode_var type;
-      CORBA::Boolean is_abstract;
-    };
+#endif /* end #if !defined */
 
-    class  FullInterfaceDescription_var
-    {
-    public:
-      FullInterfaceDescription_var (void); // default constructor
-      FullInterfaceDescription_var (FullInterfaceDescription *);
-      FullInterfaceDescription_var (const FullInterfaceDescription_var &); // copy constructor
-      ~FullInterfaceDescription_var (void); // destructor
-
-      FullInterfaceDescription_var &operator= (FullInterfaceDescription *);
-      FullInterfaceDescription_var &operator= (const FullInterfaceDescription_var &);
-      FullInterfaceDescription *operator-> (void);
-      const FullInterfaceDescription *operator-> (void) const;
-
-      operator const FullInterfaceDescription &() const;
-      operator FullInterfaceDescription &();
-      operator FullInterfaceDescription &() const;
-      // in, inout, out, _retn
-      const FullInterfaceDescription &in (void) const;
-      FullInterfaceDescription &inout (void);
-      FullInterfaceDescription *&out (void);
-      FullInterfaceDescription *_retn (void);
-      FullInterfaceDescription *ptr (void) const;
 
-    private:
-      FullInterfaceDescription *ptr_;
-    };
+#if !defined (_IR_CONSUMESDEF_CH_)
+#define _IR_CONSUMESDEF_CH_
 
-    class  FullInterfaceDescription_out
+class TAO_Export ConsumesDef: public virtual EventDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ConsumesDef_ptr _ptr_type;
+  typedef ConsumesDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static ConsumesDef_ptr _duplicate (ConsumesDef_ptr obj);
+  static ConsumesDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ConsumesDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ConsumesDef_ptr _nil (void)
     {
-    public:
-      FullInterfaceDescription_out (FullInterfaceDescription *&);
-      FullInterfaceDescription_out (FullInterfaceDescription_var &);
-      FullInterfaceDescription_out (const FullInterfaceDescription_out &);
-      FullInterfaceDescription_out &operator= (const FullInterfaceDescription_out &);
-      FullInterfaceDescription_out &operator= (FullInterfaceDescription *);
-      operator FullInterfaceDescription *&();
-      FullInterfaceDescription *&ptr (void);
-      FullInterfaceDescription *operator-> (void);
+      return (ConsumesDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  ConsumesDef (void);
+  ConsumesDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ConsumesDef (void);
+private:
+  ConsumesDef (const ConsumesDef &);
+  void operator= (const ConsumesDef &);
+};
+
+class TAO_IR_ConsumesDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ConsumesDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ConsumesDef_Default_Proxy_Factory (void);
+  
+  virtual ConsumesDef_ptr create_proxy (
+      ConsumesDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ConsumesDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ConsumesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ConsumesDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ConsumesDef_ptr create_proxy (
+      ConsumesDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ConsumesDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ConsumesDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ConsumesDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ConsumesDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ConsumesDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
 
+  typedef ACE_Singleton<TAO_IR_ConsumesDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ConsumesDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ConsumesDef_Smart_Proxy_Base : public virtual ConsumesDef
+  {
+  public:
+    TAO_IR_ConsumesDef_Smart_Proxy_Base (::IR::ConsumesDef_ptr proxy);
+    ~TAO_IR_ConsumesDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
     private:
-      FullInterfaceDescription *&ptr_;
-      // assignment from T_var not allowed
-      void operator= (const FullInterfaceDescription_var &);
-    };
+  ::IR::ConsumesDef_var base_proxy_;
+};
 
-    static CORBA::TypeCode_ptr _tc_FullInterfaceDescription;
 
-    virtual FullInterfaceDescription * describe_interface (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_AttributeDef_ptr create_attribute (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA_IDLType_ptr type,
-        CORBA::AttributeMode mode,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConsumesDef;
 
-    virtual CORBA_OperationDef_ptr create_operation (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA_IDLType_ptr result,
-        CORBA::OperationMode mode,
-        const CORBA_ParDescriptionSeq & params,
-        const CORBA_ExceptionDefSeq & exceptions,
-        const CORBA_ContextIdSeq & contexts,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+#if !defined (_IR_COMPONENTDEF___PTR_CH_)
+#define _IR_COMPONENTDEF___PTR_CH_
 
-  protected:
-    CORBA_InterfaceDef (void);
-    CORBA_InterfaceDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_InterfaceDef (void);
-  private:
-    CORBA_InterfaceDef (const CORBA_InterfaceDef &);
-    void operator= (const CORBA_InterfaceDef &);
-  };
+class ComponentDef;
+typedef ComponentDef *ComponentDef_ptr;
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEF___VAR_CH_)
+#define _IR_COMPONENTDEF___VAR_CH_
+
+class TAO_Export ComponentDef_var
+{
+public:
+  ComponentDef_var (void); // default constructor
+  ComponentDef_var (ComponentDef_ptr);
+  ComponentDef_var (const ComponentDef_var &); // copy constructor
+  ~ComponentDef_var (void); // destructor
+  
+  ComponentDef_var &operator= (ComponentDef_ptr);
+  ComponentDef_var &operator= (const ComponentDef_var &);
+  ComponentDef_ptr operator-> (void) const;
+  
+  operator const ComponentDef_ptr &() const;
+  operator ComponentDef_ptr &();
+  // in, inout, out, _retn 
+  ComponentDef_ptr in (void) const;
+  ComponentDef_ptr &inout (void);
+  ComponentDef_ptr &out (void);
+  ComponentDef_ptr _retn (void);
+  ComponentDef_ptr ptr (void) const;
+
+private:
+  ComponentDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
-  struct  CORBA_InterfaceDescription
-  {
-    static void _tao_any_destructor (void*);
 
-    TAO_String_Manager name;
-    TAO_String_Manager id;
-    TAO_String_Manager defined_in;
-    TAO_String_Manager version;
-    CORBA_RepositoryIdSeq base_interfaces;
-    CORBA::Boolean is_abstract;
-  };
+#if !defined (_IR_COMPONENTDEF___OUT_CH_)
+#define _IR_COMPONENTDEF___OUT_CH_
 
-  class TAO_Export CORBA_InterfaceDescription_var
-  {
-  public:
-    CORBA_InterfaceDescription_var (void); // default constructor
-    CORBA_InterfaceDescription_var (CORBA_InterfaceDescription *);
-    CORBA_InterfaceDescription_var (const CORBA_InterfaceDescription_var &); // copy constructor
-    ~CORBA_InterfaceDescription_var (void); // destructor
-
-    CORBA_InterfaceDescription_var &operator= (CORBA_InterfaceDescription *);
-    CORBA_InterfaceDescription_var &operator= (const CORBA_InterfaceDescription_var &);
-    CORBA_InterfaceDescription *operator-> (void);
-    const CORBA_InterfaceDescription *operator-> (void) const;
-
-    operator const CORBA_InterfaceDescription &() const;
-    operator CORBA_InterfaceDescription &();
-    operator CORBA_InterfaceDescription &() const;
-    // in, inout, out, _retn
-    const CORBA_InterfaceDescription &in (void) const;
-    CORBA_InterfaceDescription &inout (void);
-    CORBA_InterfaceDescription *&out (void);
-    CORBA_InterfaceDescription *_retn (void);
-    CORBA_InterfaceDescription *ptr (void) const;
+class TAO_Export ComponentDef_out
+{
+public:
+  ComponentDef_out (ComponentDef_ptr &);
+  ComponentDef_out (ComponentDef_var &);
+  ComponentDef_out (const ComponentDef_out &);
+  ComponentDef_out &operator= (const ComponentDef_out &);
+  ComponentDef_out &operator= (const ComponentDef_var &);
+  ComponentDef_out &operator= (ComponentDef_ptr);
+  operator ComponentDef_ptr &();
+  ComponentDef_ptr &ptr (void);
+  ComponentDef_ptr operator-> (void);
+  
+private:
+  ComponentDef_ptr &ptr_;
+};
 
-  private:
-    CORBA_InterfaceDescription *ptr_;
-  };
 
-  class TAO_Export CORBA_InterfaceDescription_out
-  {
-  public:
-    CORBA_InterfaceDescription_out (CORBA_InterfaceDescription *&);
-    CORBA_InterfaceDescription_out (CORBA_InterfaceDescription_var &);
-    CORBA_InterfaceDescription_out (const CORBA_InterfaceDescription_out &);
-    CORBA_InterfaceDescription_out &operator= (const CORBA_InterfaceDescription_out &);
-    CORBA_InterfaceDescription_out &operator= (CORBA_InterfaceDescription *);
-    operator CORBA_InterfaceDescription *&();
-    CORBA_InterfaceDescription *&ptr (void);
-    CORBA_InterfaceDescription *operator-> (void);
+#endif /* end #if !defined */
 
-  private:
-    CORBA_InterfaceDescription *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_InterfaceDescription_var &);
-  };
 
-  struct  CORBA_ValueMember
-  {
-    static void _tao_any_destructor (void*);
+#if !defined (_IR_COMPONENTDEF_CH_)
+#define _IR_COMPONENTDEF_CH_
 
-    TAO_String_Manager name;
-    TAO_String_Manager id;
-    TAO_String_Manager defined_in;
-    TAO_String_Manager version;
-    CORBA::TypeCode_var type;
-    TAO_Object_Field_T<CORBA_IDLType,CORBA_IDLType_var> type_def;
-    CORBA::Visibility access;
-  };
+class TAO_Export ComponentDef: public virtual InterfaceDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ComponentDef_ptr _ptr_type;
+  typedef ComponentDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  class TAO_Export CORBA_ValueMember_var
-  {
-  public:
-    CORBA_ValueMember_var (void); // default constructor
-    CORBA_ValueMember_var (CORBA_ValueMember *);
-    CORBA_ValueMember_var (const CORBA_ValueMember_var &); // copy constructor
-    ~CORBA_ValueMember_var (void); // destructor
-
-    CORBA_ValueMember_var &operator= (CORBA_ValueMember *);
-    CORBA_ValueMember_var &operator= (const CORBA_ValueMember_var &);
-    CORBA_ValueMember *operator-> (void);
-    const CORBA_ValueMember *operator-> (void) const;
-
-    operator const CORBA_ValueMember &() const;
-    operator CORBA_ValueMember &();
-    operator CORBA_ValueMember &() const;
-    // in, inout, out, _retn
-    const CORBA_ValueMember &in (void) const;
-    CORBA_ValueMember &inout (void);
-    CORBA_ValueMember *&out (void);
-    CORBA_ValueMember *_retn (void);
-    CORBA_ValueMember *ptr (void) const;
+  // the static operations
+  static ComponentDef_ptr _duplicate (ComponentDef_ptr obj);
+  static ComponentDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ComponentDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static ComponentDef_ptr _nil (void)
+    {
+      return (ComponentDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::InterfaceDefSeq * supported_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void supported_interfaces (
+      const IR::InterfaceDefSeq & supported_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ComponentDef_ptr base_component (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ProvidesDefSeq * provides_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::UsesDefSeq * uses_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::EmitsDefSeq * emits_events (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PublishesDefSeq * publishes_events (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ConsumesDefSeq * consumes_events (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_basic (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ProvidesDef_ptr create_provides (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::InterfaceDef_ptr interface_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::UsesDef_ptr create_uses (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::InterfaceDef_ptr interface_type,
+      CORBA::Boolean is_multiple,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::EmitsDef_ptr create_emits (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PublishesDef_ptr create_publishes (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ConsumesDef_ptr create_consumes (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
 
-  private:
-    CORBA_ValueMember *ptr_;
+protected:
+  ComponentDef (void);
+  ComponentDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~ComponentDef (void);
+private:
+  ComponentDef (const ComponentDef &);
+  void operator= (const ComponentDef &);
+};
+
+class TAO_IR_ComponentDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_ComponentDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_ComponentDef_Default_Proxy_Factory (void);
+  
+  virtual ComponentDef_ptr create_proxy (
+      ComponentDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_ComponentDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_ComponentDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_ComponentDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  ComponentDef_ptr create_proxy (
+      ComponentDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_ComponentDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_ComponentDef_Proxy_Factory_Adapter (void);
+  TAO_IR_ComponentDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_ComponentDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_ComponentDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
-  class TAO_Export CORBA_ValueMember_out
+  typedef ACE_Singleton<TAO_IR_ComponentDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_ComponentDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_ComponentDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, ComponentDef)
   {
   public:
-    CORBA_ValueMember_out (CORBA_ValueMember *&);
-    CORBA_ValueMember_out (CORBA_ValueMember_var &);
-    CORBA_ValueMember_out (const CORBA_ValueMember_out &);
-    CORBA_ValueMember_out &operator= (const CORBA_ValueMember_out &);
-    CORBA_ValueMember_out &operator= (CORBA_ValueMember *);
-    operator CORBA_ValueMember *&();
-    CORBA_ValueMember *&ptr (void);
-    CORBA_ValueMember *operator-> (void);
+    TAO_IR_ComponentDef_Smart_Proxy_Base (::IR::ComponentDef_ptr proxy);
+    ~TAO_IR_ComponentDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::InterfaceDefSeq * supported_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual void supported_interfaces (
+      const IR::InterfaceDefSeq & supported_interfaces,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ComponentDef_ptr base_component (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ProvidesDefSeq * provides_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::UsesDefSeq * uses_interfaces (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::EmitsDefSeq * emits_events (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PublishesDefSeq * publishes_events (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ConsumesDefSeq * consumes_events (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_basic (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ProvidesDef_ptr create_provides (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::InterfaceDef_ptr interface_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::UsesDef_ptr create_uses (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::InterfaceDef_ptr interface_type,
+      CORBA::Boolean is_multiple,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::EmitsDef_ptr create_emits (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PublishesDef_ptr create_publishes (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ConsumesDef_ptr create_consumes (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ValueDef_ptr value,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::ComponentDef_var base_proxy_;
+};
 
-  private:
-    CORBA_ValueMember *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ValueMember_var &);
-  };
 
+#endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDef;
+
+struct ComponentDescription;
+class ComponentDescription_var;
+
+struct TAO_Export ComponentDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef ComponentDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  TAO_String_Manager base_component;
+  ACE_NESTED_CLASS (IR, RepositoryIdSeq) supports_interfaces;
+  ACE_NESTED_CLASS (IR, ProvidesDefSeq) provides_interfaces;
+  ACE_NESTED_CLASS (IR, UsesDefSeq) uses_interfaces;
+  ACE_NESTED_CLASS (IR, AttrDescriptionSeq) attributes;
+  ACE_NESTED_CLASS (IR, EmitsDefSeq) emits_events;
+  ACE_NESTED_CLASS (IR, PublishesDefSeq) publishes_events;
+  ACE_NESTED_CLASS (IR, ConsumesDefSeq) consumes_events;
+  CORBA::Boolean is_basic;
+};
+
+class TAO_Export ComponentDescription_var
+{
+public:
+  ComponentDescription_var (void); // default constructor
+  ComponentDescription_var (ComponentDescription *);
+  ComponentDescription_var (const ComponentDescription_var &); // copy constructor
+  ~ComponentDescription_var (void); // destructor
+  
+  ComponentDescription_var &operator= (ComponentDescription *);
+  ComponentDescription_var &operator= (const ComponentDescription_var &);
+  ComponentDescription *operator-> (void);
+  const ComponentDescription *operator-> (void) const;
+  
+  operator const ComponentDescription &() const;
+  operator ComponentDescription &();
+  operator ComponentDescription &() const;
+  operator ComponentDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const ComponentDescription &in (void) const;
+  ComponentDescription &inout (void);
+  ComponentDescription *&out (void);
+  ComponentDescription *_retn (void);
+  ComponentDescription *ptr (void) const;
+
+private:
+  ComponentDescription *ptr_;
+};
+
+class TAO_Export ComponentDescription_out
+{
+public:
+  ComponentDescription_out (ComponentDescription *&);
+  ComponentDescription_out (ComponentDescription_var &);
+  ComponentDescription_out (const ComponentDescription_out &);
+  ComponentDescription_out &operator= (const ComponentDescription_out &);
+  ComponentDescription_out &operator= (ComponentDescription *);
+  operator ComponentDescription *&();
+  ComponentDescription *&ptr (void);
+  ComponentDescription *operator-> (void);
+  
+private:
+  ComponentDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const ComponentDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ComponentDescription;
+
+
+#if !defined (_IR_PRIMARYKEYDEF___PTR_CH_)
+#define _IR_PRIMARYKEYDEF___PTR_CH_
+
+class PrimaryKeyDef;
+typedef PrimaryKeyDef *PrimaryKeyDef_ptr;
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+#endif /* end #if !defined */
 
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CH_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CH_
 
-    class TAO_EXPORT_NESTED_MACRO _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq : public TAO_Unbounded_Base_Sequence
-    {
-    public:
-      // = Initialization and termination methods.
+#if !defined (_IR_PRIMARYKEYDEF___VAR_CH_)
+#define _IR_PRIMARYKEYDEF___VAR_CH_
+
+class TAO_Export PrimaryKeyDef_var
+{
+public:
+  PrimaryKeyDef_var (void); // default constructor
+  PrimaryKeyDef_var (PrimaryKeyDef_ptr);
+  PrimaryKeyDef_var (const PrimaryKeyDef_var &); // copy constructor
+  ~PrimaryKeyDef_var (void); // destructor
+  
+  PrimaryKeyDef_var &operator= (PrimaryKeyDef_ptr);
+  PrimaryKeyDef_var &operator= (const PrimaryKeyDef_var &);
+  PrimaryKeyDef_ptr operator-> (void) const;
+  
+  operator const PrimaryKeyDef_ptr &() const;
+  operator PrimaryKeyDef_ptr &();
+  // in, inout, out, _retn 
+  PrimaryKeyDef_ptr in (void) const;
+  PrimaryKeyDef_ptr &inout (void);
+  PrimaryKeyDef_ptr &out (void);
+  PrimaryKeyDef_ptr _retn (void);
+  PrimaryKeyDef_ptr ptr (void) const;
+
+private:
+  PrimaryKeyDef_ptr ptr_;
+};
 
-      _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void); // Default constructor.
-      _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum);
-      _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum,
-        CORBA::ULong length,
-        CORBA_ValueMember *data,
-        CORBA::Boolean release = 0);
-      _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs);
-      _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &operator= (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs);
-      virtual ~_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void); // Dtor.
-      // = Accessors.
-      CORBA_ValueMember &operator[] (CORBA::ULong i);
-      const CORBA_ValueMember &operator[] (CORBA::ULong i) const;
-      // = Static operations.
-      static CORBA_ValueMember *allocbuf (CORBA::ULong size);
-      static void freebuf (CORBA_ValueMember *buffer);
-      virtual void _allocate_buffer (CORBA::ULong length);
-      virtual void _deallocate_buffer (void);
-      // Implement the TAO_Base_Sequence methods (see Sequence.h)
 
-      CORBA_ValueMember *get_buffer (CORBA::Boolean orphan = 0);
-      const CORBA_ValueMember *get_buffer (void) const;
-      void replace (CORBA::ULong max,
-        CORBA::ULong length,
-        CORBA_ValueMember *data,
-        CORBA::Boolean release);
-    };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___OUT_CH_)
+#define _IR_PRIMARYKEYDEF___OUT_CH_
+
+class TAO_Export PrimaryKeyDef_out
+{
+public:
+  PrimaryKeyDef_out (PrimaryKeyDef_ptr &);
+  PrimaryKeyDef_out (PrimaryKeyDef_var &);
+  PrimaryKeyDef_out (const PrimaryKeyDef_out &);
+  PrimaryKeyDef_out &operator= (const PrimaryKeyDef_out &);
+  PrimaryKeyDef_out &operator= (const PrimaryKeyDef_var &);
+  PrimaryKeyDef_out &operator= (PrimaryKeyDef_ptr);
+  operator PrimaryKeyDef_ptr &();
+  PrimaryKeyDef_ptr &ptr (void);
+  PrimaryKeyDef_ptr operator-> (void);
+  
+private:
+  PrimaryKeyDef_ptr &ptr_;
+};
+
 
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
+#if !defined (_IR_PRIMARYKEYDEF_CH_)
+#define _IR_PRIMARYKEYDEF_CH_
 
-#if !defined (_CORBA_VALUEMEMBERSEQ_CH_)
-#define _CORBA_VALUEMEMBERSEQ_CH_
+class TAO_Export PrimaryKeyDef: public virtual Contained
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef PrimaryKeyDef_ptr _ptr_type;
+  typedef PrimaryKeyDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  // *************************************************************
-  // ValueMemberSeq
-  // *************************************************************
+  // the static operations
+  static PrimaryKeyDef_ptr _duplicate (PrimaryKeyDef_ptr obj);
+  static PrimaryKeyDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static PrimaryKeyDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static PrimaryKeyDef_ptr _nil (void)
+    {
+      return (PrimaryKeyDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean is_a (
+      const char * primary_key_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueDef_ptr primary_key (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
 
-  class TAO_Export CORBA_ValueMemberSeq : public
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-    _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq
-#else /* TAO_USE_SEQUENCE_TEMPLATES */
-    TAO_Unbounded_Sequence<CORBA_ValueMember>
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */
-  {
-  public:
-    CORBA_ValueMemberSeq (void); // default ctor
-    CORBA_ValueMemberSeq (CORBA::ULong max); // uses max size
-    CORBA_ValueMemberSeq (
-      CORBA::ULong max,
-      CORBA::ULong length,
-      CORBA_ValueMember *buffer,
-      CORBA::Boolean release=0
+protected:
+  PrimaryKeyDef (void);
+  PrimaryKeyDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~PrimaryKeyDef (void);
+private:
+  PrimaryKeyDef (const PrimaryKeyDef &);
+  void operator= (const PrimaryKeyDef &);
+};
+
+class TAO_IR_PrimaryKeyDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_PrimaryKeyDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_PrimaryKeyDef_Default_Proxy_Factory (void);
+  
+  virtual PrimaryKeyDef_ptr create_proxy (
+      PrimaryKeyDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_PrimaryKeyDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  PrimaryKeyDef_ptr create_proxy (
+      PrimaryKeyDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
     );
-    CORBA_ValueMemberSeq (const CORBA_ValueMemberSeq &); // copy ctor
-    ~CORBA_ValueMemberSeq (void); // dtor
 
-    static void _tao_any_destructor (void*);
+protected:
+  TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter (void);
+  TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_PrimaryKeyDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
+  typedef ACE_Singleton<TAO_IR_PrimaryKeyDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_PrimaryKeyDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_PrimaryKeyDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, PrimaryKeyDef)
+  {
+  public:
+    TAO_IR_PrimaryKeyDef_Smart_Proxy_Base (::IR::PrimaryKeyDef_ptr proxy);
+    ~TAO_IR_PrimaryKeyDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::Boolean is_a (
+      const char * primary_key_id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ValueDef_ptr primary_key (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::PrimaryKeyDef_var base_proxy_;
+};
+
+
 #endif /* end #if !defined */
 
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimaryKeyDef;
+
+struct PrimaryKeyDescription;
+class PrimaryKeyDescription_var;
+
+struct TAO_Export PrimaryKeyDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef PrimaryKeyDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  TAO_Object_Field_T<ACE_NESTED_CLASS (IR, ValueDef), ACE_NESTED_CLASS (IR, ValueDef_var)> primary_key;
+};
+
+class TAO_Export PrimaryKeyDescription_var
+{
+public:
+  PrimaryKeyDescription_var (void); // default constructor
+  PrimaryKeyDescription_var (PrimaryKeyDescription *);
+  PrimaryKeyDescription_var (const PrimaryKeyDescription_var &); // copy constructor
+  ~PrimaryKeyDescription_var (void); // destructor
+  
+  PrimaryKeyDescription_var &operator= (PrimaryKeyDescription *);
+  PrimaryKeyDescription_var &operator= (const PrimaryKeyDescription_var &);
+  PrimaryKeyDescription *operator-> (void);
+  const PrimaryKeyDescription *operator-> (void) const;
+  
+  operator const PrimaryKeyDescription &() const;
+  operator PrimaryKeyDescription &();
+  operator PrimaryKeyDescription &() const;
+  operator PrimaryKeyDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const PrimaryKeyDescription &in (void) const;
+  PrimaryKeyDescription &inout (void);
+  PrimaryKeyDescription *&out (void);
+  PrimaryKeyDescription *_retn (void);
+  PrimaryKeyDescription *ptr (void) const;
+
+private:
+  PrimaryKeyDescription *ptr_;
+};
+
+class TAO_Export PrimaryKeyDescription_out
+{
+public:
+  PrimaryKeyDescription_out (PrimaryKeyDescription *&);
+  PrimaryKeyDescription_out (PrimaryKeyDescription_var &);
+  PrimaryKeyDescription_out (const PrimaryKeyDescription_out &);
+  PrimaryKeyDescription_out &operator= (const PrimaryKeyDescription_out &);
+  PrimaryKeyDescription_out &operator= (PrimaryKeyDescription *);
+  operator PrimaryKeyDescription *&();
+  PrimaryKeyDescription *&ptr (void);
+  PrimaryKeyDescription *operator-> (void);
+  
+private:
+  PrimaryKeyDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const PrimaryKeyDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimaryKeyDescription;
+
+
+#if !defined (_IR_FACTORYDEF___PTR_CH_)
+#define _IR_FACTORYDEF___PTR_CH_
+
+class FactoryDef;
+typedef FactoryDef *FactoryDef_ptr;
 
-#if !defined (_CORBA_VALUEMEMBERSEQ___VAR_CH_)
-#define _CORBA_VALUEMEMBERSEQ___VAR_CH_
+#endif /* end #if !defined */
 
-// *************************************************************
-  // class CORBA::ValueMemberSeq_var
-  // *************************************************************
 
-  class TAO_Export CORBA_ValueMemberSeq_var
-  {
-  public:
-    CORBA_ValueMemberSeq_var (void); // default constructor
-    CORBA_ValueMemberSeq_var (CORBA_ValueMemberSeq *);
-    CORBA_ValueMemberSeq_var (const CORBA_ValueMemberSeq_var &); // copy constructor
-    ~CORBA_ValueMemberSeq_var (void); // destructor
-
-    CORBA_ValueMemberSeq_var &operator= (CORBA_ValueMemberSeq *);
-    CORBA_ValueMemberSeq_var &operator= (const CORBA_ValueMemberSeq_var &);
-    CORBA_ValueMemberSeq *operator-> (void);
-    const CORBA_ValueMemberSeq *operator-> (void) const;
-
-    operator const CORBA_ValueMemberSeq &() const;
-    operator CORBA_ValueMemberSeq &();
-    operator CORBA_ValueMemberSeq &() const;
-    CORBA_ValueMember &operator[] (CORBA::ULong index);
-    // in, inout, out, _retn
-    const CORBA_ValueMemberSeq &in (void) const;
-    CORBA_ValueMemberSeq &inout (void);
-    CORBA_ValueMemberSeq *&out (void);
-    CORBA_ValueMemberSeq *_retn (void);
-    CORBA_ValueMemberSeq *ptr (void) const;
+#if !defined (_IR_FACTORYDEF___VAR_CH_)
+#define _IR_FACTORYDEF___VAR_CH_
+
+class TAO_Export FactoryDef_var
+{
+public:
+  FactoryDef_var (void); // default constructor
+  FactoryDef_var (FactoryDef_ptr);
+  FactoryDef_var (const FactoryDef_var &); // copy constructor
+  ~FactoryDef_var (void); // destructor
+  
+  FactoryDef_var &operator= (FactoryDef_ptr);
+  FactoryDef_var &operator= (const FactoryDef_var &);
+  FactoryDef_ptr operator-> (void) const;
+  
+  operator const FactoryDef_ptr &() const;
+  operator FactoryDef_ptr &();
+  // in, inout, out, _retn 
+  FactoryDef_ptr in (void) const;
+  FactoryDef_ptr &inout (void);
+  FactoryDef_ptr &out (void);
+  FactoryDef_ptr _retn (void);
+  FactoryDef_ptr ptr (void) const;
+
+private:
+  FactoryDef_ptr ptr_;
+};
 
-  private:
-    CORBA_ValueMemberSeq *ptr_;
-  };
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEF___OUT_CH_)
+#define _IR_FACTORYDEF___OUT_CH_
+
+class TAO_Export FactoryDef_out
+{
+public:
+  FactoryDef_out (FactoryDef_ptr &);
+  FactoryDef_out (FactoryDef_var &);
+  FactoryDef_out (const FactoryDef_out &);
+  FactoryDef_out &operator= (const FactoryDef_out &);
+  FactoryDef_out &operator= (const FactoryDef_var &);
+  FactoryDef_out &operator= (FactoryDef_ptr);
+  operator FactoryDef_ptr &();
+  FactoryDef_ptr &ptr (void);
+  FactoryDef_ptr operator-> (void);
+  
+private:
+  FactoryDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEMEMBERSEQ___OUT_CH_)
-#define _CORBA_VALUEMEMBERSEQ___OUT_CH_
+#if !defined (_IR_FACTORYDEF_CH_)
+#define _IR_FACTORYDEF_CH_
 
-  class TAO_Export CORBA_ValueMemberSeq_out
-  {
-  public:
-    CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq *&);
-    CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq_var &);
-    CORBA_ValueMemberSeq_out (const CORBA_ValueMemberSeq_out &);
-    CORBA_ValueMemberSeq_out &operator= (const CORBA_ValueMemberSeq_out &);
-    CORBA_ValueMemberSeq_out &operator= (CORBA_ValueMemberSeq *);
-    operator CORBA_ValueMemberSeq *&();
-    CORBA_ValueMemberSeq *&ptr (void);
-    CORBA_ValueMemberSeq *operator-> (void);
-    CORBA_ValueMember &operator[] (CORBA::ULong index);
+class TAO_Export FactoryDef: public virtual OperationDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef FactoryDef_ptr _ptr_type;
+  typedef FactoryDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-  private:
-    CORBA_ValueMemberSeq *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ValueMemberSeq_var &);
-  };
+  // the static operations
+  static FactoryDef_ptr _duplicate (FactoryDef_ptr obj);
+  static FactoryDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static FactoryDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static FactoryDef_ptr _nil (void)
+    {
+      return (FactoryDef_ptr)0;
+    }
 
+  static void _tao_any_destructor (void*);
 
-#endif /* end #if !defined */
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  FactoryDef (void);
+  FactoryDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~FactoryDef (void);
+private:
+  FactoryDef (const FactoryDef &);
+  void operator= (const FactoryDef &);
+};
+
+class TAO_IR_FactoryDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_FactoryDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_FactoryDef_Default_Proxy_Factory (void);
+  
+  virtual FactoryDef_ptr create_proxy (
+      FactoryDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_FactoryDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_FactoryDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_FactoryDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  FactoryDef_ptr create_proxy (
+      FactoryDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
 
-#if !defined (_CORBA_VALUEMEMBERDEF___VAR_CH_)
-#define _CORBA_VALUEMEMBERDEF___VAR_CH_
+protected:
+  TAO_IR_FactoryDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_FactoryDef_Proxy_Factory_Adapter (void);
+  TAO_IR_FactoryDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_FactoryDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_FactoryDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
 
-  class TAO_Export CORBA_ValueMemberDef_var
+  typedef ACE_Singleton<TAO_IR_FactoryDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_FactoryDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_FactoryDef_Smart_Proxy_Base : public virtual FactoryDef
   {
   public:
-    CORBA_ValueMemberDef_var (void); // default constructor
-    CORBA_ValueMemberDef_var (CORBA_ValueMemberDef_ptr);
-    CORBA_ValueMemberDef_var (const CORBA_ValueMemberDef_var &); // copy constructor
-    ~CORBA_ValueMemberDef_var (void); // destructor
+    TAO_IR_FactoryDef_Smart_Proxy_Base (::IR::FactoryDef_ptr proxy);
+    ~TAO_IR_FactoryDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+    private:
+  ::IR::FactoryDef_var base_proxy_;
+};
 
-    CORBA_ValueMemberDef_var &operator= (CORBA_ValueMemberDef_ptr);
-    CORBA_ValueMemberDef_var &operator= (const CORBA_ValueMemberDef_var &);
-    CORBA_ValueMemberDef_ptr operator-> (void) const;
 
-    operator const CORBA_ValueMemberDef_ptr &() const;
-    operator CORBA_ValueMemberDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ValueMemberDef_ptr in (void) const;
-    CORBA_ValueMemberDef_ptr &inout (void);
-    CORBA_ValueMemberDef_ptr &out (void);
-    CORBA_ValueMemberDef_ptr _retn (void);
-    CORBA_ValueMemberDef_ptr ptr (void) const;
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FactoryDef;
 
-  private:
-    CORBA_ValueMemberDef_ptr ptr_;
-  };
 
+#if !defined (_IR_FINDERDEF___PTR_CH_)
+#define _IR_FINDERDEF___PTR_CH_
+
+class FinderDef;
+typedef FinderDef *FinderDef_ptr;
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEMEMBERDEF___OUT_CH_)
-#define _CORBA_VALUEMEMBERDEF___OUT_CH_
+#if !defined (_IR_FINDERDEF___VAR_CH_)
+#define _IR_FINDERDEF___VAR_CH_
+
+class TAO_Export FinderDef_var
+{
+public:
+  FinderDef_var (void); // default constructor
+  FinderDef_var (FinderDef_ptr);
+  FinderDef_var (const FinderDef_var &); // copy constructor
+  ~FinderDef_var (void); // destructor
+  
+  FinderDef_var &operator= (FinderDef_ptr);
+  FinderDef_var &operator= (const FinderDef_var &);
+  FinderDef_ptr operator-> (void) const;
+  
+  operator const FinderDef_ptr &() const;
+  operator FinderDef_ptr &();
+  // in, inout, out, _retn 
+  FinderDef_ptr in (void) const;
+  FinderDef_ptr &inout (void);
+  FinderDef_ptr &out (void);
+  FinderDef_ptr _retn (void);
+  FinderDef_ptr ptr (void) const;
+
+private:
+  FinderDef_ptr ptr_;
+};
 
-  class TAO_Export CORBA_ValueMemberDef_out
-  {
-  public:
-    CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_ptr &);
-    CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_var &);
-    CORBA_ValueMemberDef_out (const CORBA_ValueMemberDef_out &);
-    CORBA_ValueMemberDef_out &operator= (const CORBA_ValueMemberDef_out &);
-    CORBA_ValueMemberDef_out &operator= (const CORBA_ValueMemberDef_var &);
-    CORBA_ValueMemberDef_out &operator= (CORBA_ValueMemberDef_ptr);
-    operator CORBA_ValueMemberDef_ptr &();
-    CORBA_ValueMemberDef_ptr &ptr (void);
-    CORBA_ValueMemberDef_ptr operator-> (void);
 
-  private:
-    CORBA_ValueMemberDef_ptr &ptr_;
-  };
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEF___OUT_CH_)
+#define _IR_FINDERDEF___OUT_CH_
+
+class TAO_Export FinderDef_out
+{
+public:
+  FinderDef_out (FinderDef_ptr &);
+  FinderDef_out (FinderDef_var &);
+  FinderDef_out (const FinderDef_out &);
+  FinderDef_out &operator= (const FinderDef_out &);
+  FinderDef_out &operator= (const FinderDef_var &);
+  FinderDef_out &operator= (FinderDef_ptr);
+  operator FinderDef_ptr &();
+  FinderDef_ptr &ptr (void);
+  FinderDef_ptr operator-> (void);
+  
+private:
+  FinderDef_ptr &ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEMEMBERDEF_CH_)
-#define _CORBA_VALUEMEMBERDEF_CH_
+#if !defined (_IR_FINDERDEF_CH_)
+#define _IR_FINDERDEF_CH_
+
+class TAO_Export FinderDef: public virtual OperationDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef FinderDef_ptr _ptr_type;
+  typedef FinderDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
 
-class TAO_Export CORBA_ValueMemberDef: public virtual CORBA_Contained
+  // the static operations
+  static FinderDef_ptr _duplicate (FinderDef_ptr obj);
+  static FinderDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static FinderDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static FinderDef_ptr _nil (void)
+    {
+      return (FinderDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  FinderDef (void);
+  FinderDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~FinderDef (void);
+private:
+  FinderDef (const FinderDef &);
+  void operator= (const FinderDef &);
+};
+
+class TAO_IR_FinderDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_FinderDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_FinderDef_Default_Proxy_Factory (void);
+  
+  virtual FinderDef_ptr create_proxy (
+      FinderDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_FinderDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_FinderDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_FinderDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  FinderDef_ptr create_proxy (
+      FinderDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_FinderDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_FinderDef_Proxy_Factory_Adapter (void);
+  TAO_IR_FinderDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_FinderDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_FinderDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
+
+  typedef ACE_Singleton<TAO_IR_FinderDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_FinderDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_FinderDef_Smart_Proxy_Base : public virtual FinderDef
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_ValueMemberDef_ptr _ptr_type;
-    typedef CORBA_ValueMemberDef_var _var_type;
-  #endif /* __GNUC__ */
+    TAO_IR_FinderDef_Smart_Proxy_Base (::IR::FinderDef_ptr proxy);
+    ~TAO_IR_FinderDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+    private:
+  ::IR::FinderDef_var base_proxy_;
+};
 
-    // the static operations
-    static CORBA_ValueMemberDef_ptr _duplicate (CORBA_ValueMemberDef_ptr obj);
-    static CORBA_ValueMemberDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ValueMemberDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ValueMemberDef_ptr _nil (void)
-      {
-        return (CORBA::ValueMemberDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#endif /* end #if !defined */
 
-    virtual CORBA_IDLType_ptr type_def (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FinderDef;
 
-    virtual void type_def (
-        CORBA_IDLType_ptr type_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
 
-    virtual CORBA::Visibility access (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+#if !defined (_IR_HOMEDEF___PTR_CH_)
+#define _IR_HOMEDEF___PTR_CH_
 
-    virtual void access (
-        CORBA::Visibility access,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+class HomeDef;
+typedef HomeDef *HomeDef_ptr;
 
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
+#endif /* end #if !defined */
 
-  protected:
-    CORBA_ValueMemberDef (void);
-    CORBA_ValueMemberDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_ValueMemberDef (void);
-  private:
-    CORBA_ValueMemberDef (const CORBA_ValueMemberDef &);
-    void operator= (const CORBA_ValueMemberDef &);
-  };
+
+#if !defined (_IR_HOMEDEF___VAR_CH_)
+#define _IR_HOMEDEF___VAR_CH_
+
+class TAO_Export HomeDef_var
+{
+public:
+  HomeDef_var (void); // default constructor
+  HomeDef_var (HomeDef_ptr);
+  HomeDef_var (const HomeDef_var &); // copy constructor
+  ~HomeDef_var (void); // destructor
+  
+  HomeDef_var &operator= (HomeDef_ptr);
+  HomeDef_var &operator= (const HomeDef_var &);
+  HomeDef_ptr operator-> (void) const;
+  
+  operator const HomeDef_ptr &() const;
+  operator HomeDef_ptr &();
+  // in, inout, out, _retn 
+  HomeDef_ptr in (void) const;
+  HomeDef_ptr &inout (void);
+  HomeDef_ptr &out (void);
+  HomeDef_ptr _retn (void);
+  HomeDef_ptr ptr (void) const;
+
+private:
+  HomeDef_ptr ptr_;
+};
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEDEF___VAR_CH_)
-#define _CORBA_VALUEDEF___VAR_CH_
+#if !defined (_IR_HOMEDEF___OUT_CH_)
+#define _IR_HOMEDEF___OUT_CH_
+
+class TAO_Export HomeDef_out
+{
+public:
+  HomeDef_out (HomeDef_ptr &);
+  HomeDef_out (HomeDef_var &);
+  HomeDef_out (const HomeDef_out &);
+  HomeDef_out &operator= (const HomeDef_out &);
+  HomeDef_out &operator= (const HomeDef_var &);
+  HomeDef_out &operator= (HomeDef_ptr);
+  operator HomeDef_ptr &();
+  HomeDef_ptr &ptr (void);
+  HomeDef_ptr operator-> (void);
+  
+private:
+  HomeDef_ptr &ptr_;
+};
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF_CH_)
+#define _IR_HOMEDEF_CH_
+
+class TAO_Export HomeDef: public virtual InterfaceDef
+{
+public:
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef HomeDef_ptr _ptr_type;
+  typedef HomeDef_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  // the static operations
+  static HomeDef_ptr _duplicate (HomeDef_ptr obj);
+  static HomeDef_ptr _narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static HomeDef_ptr _unchecked_narrow (
+      CORBA::Object_ptr obj,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  static HomeDef_ptr _nil (void)
+    {
+      return (HomeDef_ptr)0;
+    }
+
+  static void _tao_any_destructor (void*);
+
+  virtual IR::HomeDef_ptr base_home (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ComponentDef_ptr managed_component (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PrimaryKeyDef_ptr primary_key (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FactoryDefSeq * factories (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FinderDefSeq * finders (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_basic (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PrimaryKeyDef_ptr create_primary_key (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ValueDef_ptr primary_key,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FactoryDef_ptr create_factory (
+      const char * id,
+      const char * name,
+      const char * version,
+      const IR::ParDescriptionSeq & params,
+      const IR::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FinderDef_ptr create_finder (
+      const char * id,
+      const char * name,
+      const char * version,
+      const IR::ParDescriptionSeq & params,
+      const IR::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean _is_a (
+      const CORBA::Char *type_id, 
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  virtual const char* _interface_repository_id (void) const;
+
+protected:
+  HomeDef (void);
+  HomeDef (TAO_Stub *objref, 
+      TAO_ServantBase *_tao_servant = 0, 
+      CORBA::Boolean _tao_collocated = 0
+    );
+  virtual ~HomeDef (void);
+private:
+  HomeDef (const HomeDef &);
+  void operator= (const HomeDef &);
+};
+
+class TAO_IR_HomeDef_Default_Proxy_Factory
+{
+public:
+  
+  TAO_IR_HomeDef_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_IR_HomeDef_Default_Proxy_Factory (void);
+  
+  virtual HomeDef_ptr create_proxy (
+      HomeDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_IR_HomeDef_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_IR_HomeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_IR_HomeDef_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  HomeDef_ptr create_proxy (
+      HomeDef_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+
+protected:
+  TAO_IR_HomeDef_Proxy_Factory_Adapter (void);
+  ~TAO_IR_HomeDef_Proxy_Factory_Adapter (void);
+  TAO_IR_HomeDef_Proxy_Factory_Adapter &operator= (
+      const TAO_IR_HomeDef_Proxy_Factory_Adapter &
+    );
+  TAO_IR_HomeDef_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
+  };
 
-  class TAO_Export CORBA_ValueDef_var
+  typedef ACE_Singleton<TAO_IR_HomeDef_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_IR_HomeDef_PROXY_FACTORY_ADAPTER;
+  class TAO_IR_HomeDef_Smart_Proxy_Base : public virtual ACE_NESTED_CLASS (IR, HomeDef)
   {
   public:
-    CORBA_ValueDef_var (void); // default constructor
-    CORBA_ValueDef_var (CORBA_ValueDef_ptr);
-    CORBA_ValueDef_var (const CORBA_ValueDef_var &); // copy constructor
-    ~CORBA_ValueDef_var (void); // destructor
+    TAO_IR_HomeDef_Smart_Proxy_Base (::IR::HomeDef_ptr proxy);
+    ~TAO_IR_HomeDef_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual IR::HomeDef_ptr base_home (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::ComponentDef_ptr managed_component (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PrimaryKeyDef_ptr primary_key (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FactoryDefSeq * factories (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FinderDefSeq * finders (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::Boolean is_basic (
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::PrimaryKeyDef_ptr create_primary_key (
+      const char * id,
+      const char * name,
+      const char * version,
+      IR::ValueDef_ptr primary_key,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FactoryDef_ptr create_factory (
+      const char * id,
+      const char * name,
+      const char * version,
+      const IR::ParDescriptionSeq & params,
+      const IR::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual IR::FinderDef_ptr create_finder (
+      const char * id,
+      const char * name,
+      const char * version,
+      const IR::ParDescriptionSeq & params,
+      const IR::ExceptionDefSeq & exceptions,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::IR::HomeDef_var base_proxy_;
+};
 
-    CORBA_ValueDef_var &operator= (CORBA_ValueDef_ptr);
-    CORBA_ValueDef_var &operator= (const CORBA_ValueDef_var &);
-    CORBA_ValueDef_ptr operator-> (void) const;
 
-    operator const CORBA_ValueDef_ptr &() const;
-    operator CORBA_ValueDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ValueDef_ptr in (void) const;
-    CORBA_ValueDef_ptr &inout (void);
-    CORBA_ValueDef_ptr &out (void);
-    CORBA_ValueDef_ptr _retn (void);
-    CORBA_ValueDef_ptr ptr (void) const;
+#endif /* end #if !defined */
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDef;
+
+struct HomeDescription;
+class HomeDescription_var;
+
+struct TAO_Export HomeDescription
+{
+
+#if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+  typedef HomeDescription_var _var_type;
+#endif /* ! __GNUC__ || g++ >= 2.8 */
+
+  static void _tao_any_destructor (void*);
+
+  TAO_String_Manager name;
+  TAO_String_Manager id;
+  TAO_String_Manager defined_in;
+  TAO_String_Manager version;
+  TAO_String_Manager base_home;
+  TAO_String_Manager managed_component;
+  TAO_Object_Field_T<ACE_NESTED_CLASS (IR, PrimaryKeyDef), ACE_NESTED_CLASS (IR, PrimaryKeyDef_var)> primary_key_def;
+  ACE_NESTED_CLASS (IR, FactoryDefSeq) factories;
+  ACE_NESTED_CLASS (IR, FinderDefSeq) finders;
+  ACE_NESTED_CLASS (IR, OpDescriptionSeq) operations;
+  ACE_NESTED_CLASS (IR, AttrDescriptionSeq) attributes;
+  CORBA::Boolean is_basic;
+};
+
+class TAO_Export HomeDescription_var
+{
+public:
+  HomeDescription_var (void); // default constructor
+  HomeDescription_var (HomeDescription *);
+  HomeDescription_var (const HomeDescription_var &); // copy constructor
+  ~HomeDescription_var (void); // destructor
+  
+  HomeDescription_var &operator= (HomeDescription *);
+  HomeDescription_var &operator= (const HomeDescription_var &);
+  HomeDescription *operator-> (void);
+  const HomeDescription *operator-> (void) const;
+  
+  operator const HomeDescription &() const;
+  operator HomeDescription &();
+  operator HomeDescription &() const;
+  operator HomeDescription *&(); // variable-size types only
+  
+  // in, inout, out, _retn 
+  const HomeDescription &in (void) const;
+  HomeDescription &inout (void);
+  HomeDescription *&out (void);
+  HomeDescription *_retn (void);
+  HomeDescription *ptr (void) const;
+
+private:
+  HomeDescription *ptr_;
+};
+
+class TAO_Export HomeDescription_out
+{
+public:
+  HomeDescription_out (HomeDescription *&);
+  HomeDescription_out (HomeDescription_var &);
+  HomeDescription_out (const HomeDescription_out &);
+  HomeDescription_out &operator= (const HomeDescription_out &);
+  HomeDescription_out &operator= (HomeDescription *);
+  operator HomeDescription *&();
+  HomeDescription *&ptr (void);
+  HomeDescription *operator-> (void);
+  
+private:
+  HomeDescription *&ptr_;
+  // assignment from T_var not allowed
+  void operator= (const HomeDescription_var &);
+};
+
+TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_HomeDescription;
+
+
+}
+TAO_NAMESPACE_CLOSE // module IR
+
+#if !defined (_CORBA_TYPECODEFACTORY___VAR_CH_)
+#define _CORBA_TYPECODEFACTORY___VAR_CH_
+
+  class TAO_Export CORBA_TypeCodeFactory_var
+  {
+  public:
+    CORBA_TypeCodeFactory_var (void); // default constructor
+    CORBA_TypeCodeFactory_var (CORBA_TypeCodeFactory_ptr);
+    CORBA_TypeCodeFactory_var (const CORBA_TypeCodeFactory_var &); // copy constructor
+    ~CORBA_TypeCodeFactory_var (void); // destructor
+    
+    CORBA_TypeCodeFactory_var &operator= (CORBA_TypeCodeFactory_ptr);
+    CORBA_TypeCodeFactory_var &operator= (const CORBA_TypeCodeFactory_var &);
+    CORBA_TypeCodeFactory_ptr operator-> (void) const;
+    
+    operator const CORBA_TypeCodeFactory_ptr &() const;
+    operator CORBA_TypeCodeFactory_ptr &();
+    // in, inout, out, _retn 
+    CORBA_TypeCodeFactory_ptr in (void) const;
+    CORBA_TypeCodeFactory_ptr &inout (void);
+    CORBA_TypeCodeFactory_ptr &out (void);
+    CORBA_TypeCodeFactory_ptr _retn (void);
+    CORBA_TypeCodeFactory_ptr ptr (void) const;
 
   private:
-    CORBA_ValueDef_ptr ptr_;
+    CORBA_TypeCodeFactory_ptr ptr_;
   };
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEDEF___OUT_CH_)
-#define _CORBA_VALUEDEF___OUT_CH_
+#if !defined (_CORBA_TYPECODEFACTORY___OUT_CH_)
+#define _CORBA_TYPECODEFACTORY___OUT_CH_
 
-  class TAO_Export CORBA_ValueDef_out
+  class TAO_Export CORBA_TypeCodeFactory_out
   {
   public:
-    CORBA_ValueDef_out (CORBA_ValueDef_ptr &);
-    CORBA_ValueDef_out (CORBA_ValueDef_var &);
-    CORBA_ValueDef_out (const CORBA_ValueDef_out &);
-    CORBA_ValueDef_out &operator= (const CORBA_ValueDef_out &);
-    CORBA_ValueDef_out &operator= (const CORBA_ValueDef_var &);
-    CORBA_ValueDef_out &operator= (CORBA_ValueDef_ptr);
-    operator CORBA_ValueDef_ptr &();
-    CORBA_ValueDef_ptr &ptr (void);
-    CORBA_ValueDef_ptr operator-> (void);
-
+    CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_ptr &);
+    CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_var &);
+    CORBA_TypeCodeFactory_out (const CORBA_TypeCodeFactory_out &);
+    CORBA_TypeCodeFactory_out &operator= (const CORBA_TypeCodeFactory_out &);
+    CORBA_TypeCodeFactory_out &operator= (const CORBA_TypeCodeFactory_var &);
+    CORBA_TypeCodeFactory_out &operator= (CORBA_TypeCodeFactory_ptr);
+    operator CORBA_TypeCodeFactory_ptr &();
+    CORBA_TypeCodeFactory_ptr &ptr (void);
+    CORBA_TypeCodeFactory_ptr operator-> (void);
+    
   private:
-    CORBA_ValueDef_ptr &ptr_;
+    CORBA_TypeCodeFactory_ptr &ptr_;
   };
 
 
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEDEF_CH_)
-#define _CORBA_VALUEDEF_CH_
+#if !defined (_CORBA_TYPECODEFACTORY_CH_)
+#define _CORBA_TYPECODEFACTORY_CH_
 
-class TAO_Export CORBA_ValueDef: public virtual CORBA_Container, public virtual CORBA_Contained, public virtual CORBA_IDLType
+class TAO_Export CORBA_TypeCodeFactory : public virtual ACE_CORBA_1 (Object)
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_ValueDef_ptr _ptr_type;
-    typedef CORBA_ValueDef_var _var_type;
-  #endif /* __GNUC__ */
+  #if !defined(__GNUC__) || !defined (ACE_HAS_GNUG_PRE_2_8)
+    typedef CORBA_TypeCodeFactory_ptr _ptr_type;
+    typedef CORBA_TypeCodeFactory_var _var_type;
+  #endif /* ! __GNUC__ || g++ >= 2.8 */
 
     // the static operations
-    static CORBA_ValueDef_ptr _duplicate (CORBA_ValueDef_ptr obj);
-    static CORBA_ValueDef_ptr _narrow (
+    static CORBA_TypeCodeFactory_ptr _duplicate (CORBA_TypeCodeFactory_ptr obj);
+    static CORBA_TypeCodeFactory_ptr _narrow (
         CORBA::Object_ptr obj,
-        CORBA::Environment &env =
+        CORBA::Environment &env = 
           TAO_default_environment ()
       );
-    static CORBA_ValueDef_ptr _unchecked_narrow (
+    static CORBA_TypeCodeFactory_ptr _unchecked_narrow (
         CORBA::Object_ptr obj,
-        CORBA::Environment &env =
+        CORBA::Environment &env = 
           TAO_default_environment ()
       );
-    static CORBA_ValueDef_ptr _nil (void)
+    static CORBA_TypeCodeFactory_ptr _nil (void)
       {
-        return (CORBA::ValueDef_ptr)0;
+        return (CORBA_TypeCodeFactory_ptr)0;
       }
-    static void _tao_any_destructor (void*);
 
-    virtual CORBA_InterfaceDef_ptr supported_interface (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
+    static void _tao_any_destructor (void*);
 
-    virtual void supported_interface (
-        CORBA_InterfaceDef_ptr supported_interface,
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_struct_tc (
+        const char * id,
+        const char * name,
+        const IR::StructMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA_InitializerSeq * initializers (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_union_tc (
+        const char * id,
+        const char * name,
+        CORBA::TypeCode_ptr discriminator_type,
+        const IR::UnionMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual void initializers (
-        const CORBA_InitializerSeq & initializers,
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_enum_tc (
+        const char * id,
+        const char * name,
+        const IR::EnumMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA_ValueDef_ptr base_value (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_alias_tc (
+        const char * id,
+        const char * name,
+        CORBA::TypeCode_ptr original_type,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual void base_value (
-        CORBA_ValueDef_ptr base_value,
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_exception_tc (
+        const char * id,
+        const char * name,
+        const IR::StructMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA_ValueDefSeq * abstract_base_values (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_interface_tc (
+        const char * id,
+        const char * name,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual void abstract_base_values (
-        const CORBA_ValueDefSeq & abstract_base_values,
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_string_tc (
+        CORBA::ULong bound,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA::Boolean is_abstract (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_wstring_tc (
+        CORBA::ULong bound,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual void is_abstract (
-        CORBA::Boolean is_abstract,
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_fixed_tc (
+        CORBA::UShort digits,
+        CORBA::UShort scale,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA::Boolean is_custom (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_sequence_tc (
+        CORBA::ULong bound,
+        CORBA::TypeCode_ptr element_type,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual void is_custom (
-        CORBA::Boolean is_custom,
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_array_tc (
+        CORBA::ULong length,
+        CORBA::TypeCode_ptr element_type,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA::Boolean is_truncatable (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_value_tc (
+        const char * id,
+        const char * name,
+        CORBA::ValueModifier type_modifier,
+        CORBA::TypeCode_ptr concrete_base,
+        const IR::ValueMemberSeq & members,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual void is_truncatable (
-        CORBA::Boolean is_truncatable,
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_value_box_tc (
+        const char * id,
+        const char * name,
+        CORBA::TypeCode_ptr boxed_type,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA::Boolean is_a (
-        const char * value_id,
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_native_tc (
+        const char * id,
+        const char * name,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    struct  FullValueDescription
-    {
-      static void _tao_any_destructor (void*);
-
-      TAO_String_Manager name;
-      TAO_String_Manager id;
-      CORBA::Boolean is_abstract;
-      CORBA::Boolean is_custom;
-      TAO_String_Manager defined_in;
-      TAO_String_Manager version;
-      CORBA_OpDescriptionSeq operations;
-      CORBA_AttrDescriptionSeq attributes;
-      CORBA_ValueMemberSeq members;
-      CORBA_InitializerSeq initializers;
-      CORBA_RepositoryIdSeq supported_interfaces;
-      CORBA_RepositoryIdSeq abstract_base_values;
-      CORBA::Boolean is_truncatable;
-      TAO_String_Manager base_value;
-      CORBA::TypeCode_var type;
-    };
-
-    class  FullValueDescription_var
-    {
-    public:
-      FullValueDescription_var (void); // default constructor
-      FullValueDescription_var (FullValueDescription *);
-      FullValueDescription_var (const FullValueDescription_var &); // copy constructor
-      ~FullValueDescription_var (void); // destructor
-
-      FullValueDescription_var &operator= (FullValueDescription *);
-      FullValueDescription_var &operator= (const FullValueDescription_var &);
-      FullValueDescription *operator-> (void);
-      const FullValueDescription *operator-> (void) const;
-
-      operator const FullValueDescription &() const;
-      operator FullValueDescription &();
-      operator FullValueDescription &() const;
-      // in, inout, out, _retn
-      const FullValueDescription &in (void) const;
-      FullValueDescription &inout (void);
-      FullValueDescription *&out (void);
-      FullValueDescription *_retn (void);
-      FullValueDescription *ptr (void) const;
-
-    private:
-      FullValueDescription *ptr_;
-    };
-
-    class  FullValueDescription_out
-    {
-    public:
-      FullValueDescription_out (FullValueDescription *&);
-      FullValueDescription_out (FullValueDescription_var &);
-      FullValueDescription_out (const FullValueDescription_out &);
-      FullValueDescription_out &operator= (const FullValueDescription_out &);
-      FullValueDescription_out &operator= (FullValueDescription *);
-      operator FullValueDescription *&();
-      FullValueDescription *&ptr (void);
-      FullValueDescription *operator-> (void);
-
-    private:
-      FullValueDescription *&ptr_;
-      // assignment from T_var not allowed
-      void operator= (const FullValueDescription_var &);
-    };
-
-    static CORBA::TypeCode_ptr _tc_FullValueDescription;
-
-    virtual FullValueDescription * describe_value (
-        CORBA::Environment &ACE_TRY_ENV =
+    virtual CORBA::TypeCode_ptr create_recursive_tc (
+        const char * id,
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA_ValueMemberDef_ptr create_value_member (
+    virtual CORBA::TypeCode_ptr create_abstract_interface_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA_IDLType_ptr type,
-        CORBA::Visibility access,
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA_AttributeDef_ptr create_attribute (
+    virtual CORBA::TypeCode_ptr create_component_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA_IDLType_ptr type,
-        CORBA::AttributeMode mode,
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
 
-    virtual CORBA_OperationDef_ptr create_operation (
+    virtual CORBA::TypeCode_ptr create_home_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA_IDLType_ptr result,
-        CORBA::OperationMode mode,
-        const CORBA_ParDescriptionSeq & params,
-        const CORBA_ExceptionDefSeq & exceptions,
-        const CORBA_ContextIdSeq & contexts,
-        CORBA::Environment &ACE_TRY_ENV =
+        CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
@@ -7866,989 +17543,1246 @@ class TAO_Export CORBA_ValueDef: public virtual CORBA_Container, public virtual
       ));
 
     virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
+        const CORBA::Char *type_id, 
+        CORBA::Environment &env = 
           TAO_default_environment ()
       );
     virtual const char* _interface_repository_id (void) const;
 
   protected:
-    CORBA_ValueDef (void);
-    CORBA_ValueDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
+    CORBA_TypeCodeFactory (void);
+    CORBA_TypeCodeFactory (TAO_Stub *objref, 
+        TAO_ServantBase *_tao_servant = 0, 
         CORBA::Boolean _tao_collocated = 0
       );
-    virtual ~CORBA_ValueDef (void);
-  private:
-    CORBA_ValueDef (const CORBA_ValueDef &);
-    void operator= (const CORBA_ValueDef &);
-  };
-
-
-#endif /* end #if !defined */
-
-  struct  CORBA_ValueDescription
-  {
-    static void _tao_any_destructor (void*);
-
-    TAO_String_Manager name;
-    TAO_String_Manager id;
-    CORBA::Boolean is_abstract;
-    CORBA::Boolean is_custom;
-    TAO_String_Manager defined_in;
-    TAO_String_Manager version;
-    TAO_String_Manager supported_interface;
-    CORBA_RepositoryIdSeq abstract_base_values;
-    CORBA::Boolean is_truncatable;
-    TAO_String_Manager base_value;
-  };
-
-  class TAO_Export CORBA_ValueDescription_var
-  {
-  public:
-    CORBA_ValueDescription_var (void); // default constructor
-    CORBA_ValueDescription_var (CORBA_ValueDescription *);
-    CORBA_ValueDescription_var (const CORBA_ValueDescription_var &); // copy constructor
-    ~CORBA_ValueDescription_var (void); // destructor
-
-    CORBA_ValueDescription_var &operator= (CORBA_ValueDescription *);
-    CORBA_ValueDescription_var &operator= (const CORBA_ValueDescription_var &);
-    CORBA_ValueDescription *operator-> (void);
-    const CORBA_ValueDescription *operator-> (void) const;
-
-    operator const CORBA_ValueDescription &() const;
-    operator CORBA_ValueDescription &();
-    operator CORBA_ValueDescription &() const;
-    // in, inout, out, _retn
-    const CORBA_ValueDescription &in (void) const;
-    CORBA_ValueDescription &inout (void);
-    CORBA_ValueDescription *&out (void);
-    CORBA_ValueDescription *_retn (void);
-    CORBA_ValueDescription *ptr (void) const;
-
+    virtual ~CORBA_TypeCodeFactory (void);
   private:
-    CORBA_ValueDescription *ptr_;
-  };
-
-  class TAO_Export CORBA_ValueDescription_out
-  {
-  public:
-    CORBA_ValueDescription_out (CORBA_ValueDescription *&);
-    CORBA_ValueDescription_out (CORBA_ValueDescription_var &);
-    CORBA_ValueDescription_out (const CORBA_ValueDescription_out &);
-    CORBA_ValueDescription_out &operator= (const CORBA_ValueDescription_out &);
-    CORBA_ValueDescription_out &operator= (CORBA_ValueDescription *);
-    operator CORBA_ValueDescription *&();
-    CORBA_ValueDescription *&ptr (void);
-    CORBA_ValueDescription *operator-> (void);
-
-  private:
-    CORBA_ValueDescription *&ptr_;
-    // assignment from T_var not allowed
-    void operator= (const CORBA_ValueDescription_var &);
-  };
-
-
-#if !defined (_CORBA_VALUEBOXDEF___VAR_CH_)
-#define _CORBA_VALUEBOXDEF___VAR_CH_
-
-  class TAO_Export CORBA_ValueBoxDef_var
-  {
-  public:
-    CORBA_ValueBoxDef_var (void); // default constructor
-    CORBA_ValueBoxDef_var (CORBA_ValueBoxDef_ptr);
-    CORBA_ValueBoxDef_var (const CORBA_ValueBoxDef_var &); // copy constructor
-    ~CORBA_ValueBoxDef_var (void); // destructor
-
-    CORBA_ValueBoxDef_var &operator= (CORBA_ValueBoxDef_ptr);
-    CORBA_ValueBoxDef_var &operator= (const CORBA_ValueBoxDef_var &);
-    CORBA_ValueBoxDef_ptr operator-> (void) const;
-
-    operator const CORBA_ValueBoxDef_ptr &() const;
-    operator CORBA_ValueBoxDef_ptr &();
-    // in, inout, out, _retn
-    CORBA_ValueBoxDef_ptr in (void) const;
-    CORBA_ValueBoxDef_ptr &inout (void);
-    CORBA_ValueBoxDef_ptr &out (void);
-    CORBA_ValueBoxDef_ptr _retn (void);
-    CORBA_ValueBoxDef_ptr ptr (void) const;
-
-  private:
-    CORBA_ValueBoxDef_ptr ptr_;
-  };
-
-
-#endif /* end #if !defined */
-
-
-#if !defined (_CORBA_VALUEBOXDEF___OUT_CH_)
-#define _CORBA_VALUEBOXDEF___OUT_CH_
-
-  class TAO_Export CORBA_ValueBoxDef_out
-  {
-  public:
-    CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_ptr &);
-    CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_var &);
-    CORBA_ValueBoxDef_out (const CORBA_ValueBoxDef_out &);
-    CORBA_ValueBoxDef_out &operator= (const CORBA_ValueBoxDef_out &);
-    CORBA_ValueBoxDef_out &operator= (const CORBA_ValueBoxDef_var &);
-    CORBA_ValueBoxDef_out &operator= (CORBA_ValueBoxDef_ptr);
-    operator CORBA_ValueBoxDef_ptr &();
-    CORBA_ValueBoxDef_ptr &ptr (void);
-    CORBA_ValueBoxDef_ptr operator-> (void);
+    CORBA_TypeCodeFactory (const CORBA_TypeCodeFactory &);
+    void operator= (const CORBA_TypeCodeFactory &);
+};
+
+class TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory
+{
+public:
+  
+  TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory (int register_proxy_factory = 1);
+  
+  virtual ~TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory (void);
+  
+  virtual CORBA_TypeCodeFactory_ptr create_proxy (
+      CORBA_TypeCodeFactory_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+};
+
+class TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter
+{
+public:
+  
+  friend class ACE_Singleton<TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX>;
+  
+  int register_proxy_factory (
+      TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory *df,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  int unregister_proxy_factory (
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
+  
+  CORBA_TypeCodeFactory_ptr create_proxy (
+      CORBA_TypeCodeFactory_ptr proxy,
+      CORBA::Environment &env = 
+        TAO_default_environment ()
+    );
 
-  private:
-    CORBA_ValueBoxDef_ptr &ptr_;
+protected:
+  TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter (void);
+  ~TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter (void);
+  TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter &operator= (
+      const TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter &
+    );
+  TAO_CORBA_TypeCodeFactory_Default_Proxy_Factory *proxy_factory_;
+  int delete_proxy_factory_;
+  ACE_SYNCH_RECURSIVE_MUTEX lock_;
   };
 
-
-#endif /* end #if !defined */
-
-
-#if !defined (_CORBA_VALUEBOXDEF_CH_)
-#define _CORBA_VALUEBOXDEF_CH_
-
-class TAO_Export CORBA_ValueBoxDef: public virtual CORBA_IDLType
+  typedef ACE_Singleton<TAO_CORBA_TypeCodeFactory_Proxy_Factory_Adapter, ACE_SYNCH_RECURSIVE_MUTEX> TAO_CORBA_TypeCodeFactory_PROXY_FACTORY_ADAPTER;
+  class TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base : public virtual CORBA_TypeCodeFactory
   {
   public:
-  #if !defined(__GNUC__) || __GNUC__ > 2 || __GNUC_MINOR__ >= 8
-    typedef CORBA_ValueBoxDef_ptr _ptr_type;
-    typedef CORBA_ValueBoxDef_var _var_type;
-  #endif /* __GNUC__ */
-
-    // the static operations
-    static CORBA_ValueBoxDef_ptr _duplicate (CORBA_ValueBoxDef_ptr obj);
-    static CORBA_ValueBoxDef_ptr _narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ValueBoxDef_ptr _unchecked_narrow (
-        CORBA::Object_ptr obj,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    static CORBA_ValueBoxDef_ptr _nil (void)
-      {
-        return (CORBA::ValueBoxDef_ptr)0;
-      }
-    static void _tao_any_destructor (void*);
-
-    virtual CORBA_IDLType_ptr original_type_def (
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void original_type_def (
-        CORBA_IDLType_ptr original_type_def,
-        CORBA::Environment &ACE_TRY_ENV =
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Boolean _is_a (
-        const CORBA::Char *type_id,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-    virtual const char* _interface_repository_id (void) const;
-
-  protected:
-    CORBA_ValueBoxDef (void);
-    CORBA_ValueBoxDef (TAO_Stub *objref,
-        TAO_ServantBase *_tao_servant = 0,
-        CORBA::Boolean _tao_collocated = 0
-      );
-    virtual ~CORBA_ValueBoxDef (void);
-  private:
-    CORBA_ValueBoxDef (const CORBA_ValueBoxDef &);
-    void operator= (const CORBA_ValueBoxDef &);
-  };
+    TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base (::CORBA::TypeCodeFactory_ptr proxy);
+    ~TAO_CORBA_TypeCodeFactory_Smart_Proxy_Base (void);
+    virtual TAO_Stub *_stubobj (void) const;
+      virtual CORBA::TypeCode_ptr create_struct_tc (
+      const char * id,
+      const char * name,
+      const IR::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_union_tc (
+      const char * id,
+      const char * name,
+      CORBA::TypeCode_ptr discriminator_type,
+      const IR::UnionMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_enum_tc (
+      const char * id,
+      const char * name,
+      const IR::EnumMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_alias_tc (
+      const char * id,
+      const char * name,
+      CORBA::TypeCode_ptr original_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_exception_tc (
+      const char * id,
+      const char * name,
+      const IR::StructMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_interface_tc (
+      const char * id,
+      const char * name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_string_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_wstring_tc (
+      CORBA::ULong bound,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_fixed_tc (
+      CORBA::UShort digits,
+      CORBA::UShort scale,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_sequence_tc (
+      CORBA::ULong bound,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_array_tc (
+      CORBA::ULong length,
+      CORBA::TypeCode_ptr element_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_value_tc (
+      const char * id,
+      const char * name,
+      CORBA::ValueModifier type_modifier,
+      CORBA::TypeCode_ptr concrete_base,
+      const IR::ValueMemberSeq & members,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_value_box_tc (
+      const char * id,
+      const char * name,
+      CORBA::TypeCode_ptr boxed_type,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_native_tc (
+      const char * id,
+      const char * name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_recursive_tc (
+      const char * id,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_abstract_interface_tc (
+      const char * id,
+      const char * name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_component_tc (
+      const char * id,
+      const char * name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+  virtual CORBA::TypeCode_ptr create_home_tc (
+      const char * id,
+      const char * name,
+      CORBA::Environment &ACE_TRY_ENV = 
+        TAO_default_environment ()
+    )
+    ACE_THROW_SPEC ((
+      CORBA::SystemException
+    ));
+
+private:
+  ::CORBA::TypeCodeFactory_var base_proxy_;
+};
 
 
 #endif /* end #if !defined */
 
-TAO_Export void  operator<<= (CORBA::Any &, CORBA::DefinitionKind);
-TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::DefinitionKind &);
-extern TAO_Export CORBA::IRObject_ptr (*_TAO_collocation_CORBA_IRObject_Stub_Factory_function_pointer) (
+TAO_Export void operator<<= (CORBA::Any &, IR_DefinitionKind);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR_DefinitionKind &);
+extern TAO_Export IR::Contained_ptr (*_TAO_collocation_IR_Contained_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::Contained
+TAO_Export void operator<<= (CORBA::Any &, IR::Contained_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Contained *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::Contained::Description &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::Contained::Description*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Contained::Description *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::Contained::Description *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::InterfaceDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::InterfaceDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::InterfaceDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::InterfaceDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ValueDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ValueDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ValueDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ComponentDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ComponentDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ComponentDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ProvidesDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ProvidesDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ProvidesDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::UsesDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::UsesDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UsesDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::HomeDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::HomeDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::HomeDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::HomeDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::EmitsDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::EmitsDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EmitsDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::EmitsDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::PublishesDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::PublishesDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PublishesDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::PublishesDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ConsumesDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ConsumesDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConsumesDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ConsumesDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::FactoryDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::FactoryDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FactoryDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::FactoryDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::FinderDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::FinderDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FinderDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::FinderDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ContainedSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ContainedSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ContainedSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ContainedSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::StructMember &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::StructMember*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::StructMember *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::StructMember *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::StructMemberSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::StructMemberSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::StructMemberSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::StructMemberSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::Initializer &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::Initializer*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Initializer *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::Initializer *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::InitializerSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::InitializerSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::InitializerSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::InitializerSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::UnionMember &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::UnionMember*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UnionMember *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UnionMember *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::UnionMemberSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::UnionMemberSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UnionMemberSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UnionMemberSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::EnumMemberSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::EnumMemberSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EnumMemberSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::EnumMemberSeq *&);
+extern TAO_Export IR::Container_ptr (*_TAO_collocation_IR_Container_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::Container
+TAO_Export void operator<<= (CORBA::Any &, IR::Container_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Container *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::Container::Description &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::Container::Description*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Container::Description *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::Container::Description *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::Container::DescriptionSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::Container::DescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Container::DescriptionSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::Container::DescriptionSeq *&);
+extern TAO_Export IR::IDLType_ptr (*_TAO_collocation_IR_IDLType_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::IDLType
+TAO_Export void operator<<= (CORBA::Any &, IR::IDLType_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::IDLType *&);
+TAO_Export void operator<<= (CORBA::Any &, IR::PrimitiveKind);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimitiveKind &);
+extern TAO_Export IR::Repository_ptr (*_TAO_collocation_IR_Repository_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::Repository
+TAO_Export void operator<<= (CORBA::Any &, IR::Repository_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::Repository *&);
+extern TAO_Export IR::ComponentRepository_ptr (*_TAO_collocation_IR_ComponentRepository_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::ComponentRepository
+TAO_Export void operator<<= (CORBA::Any &, IR::ComponentRepository_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentRepository *&);
+extern TAO_Export IR::ModuleDef_ptr (*_TAO_collocation_IR_ModuleDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::ModuleDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ModuleDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ModuleDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ModuleDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ModuleDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ModuleDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ModuleDescription *&);
+extern TAO_Export IR::ConstantDef_ptr (*_TAO_collocation_IR_ConstantDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::ConstantDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ConstantDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConstantDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ConstantDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ConstantDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConstantDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ConstantDescription *&);
+extern TAO_Export IR::TypedefDef_ptr (*_TAO_collocation_IR_TypedefDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::IRObject
-TAO_Export void  operator<<= (CORBA::Any &, CORBA::IRObject_ptr);
-TAO_Export CORBA::Boolean  operator>>= (const CORBA::Any &, CORBA::IRObject *&);
-extern TAO_Export CORBA::Contained_ptr (*_TAO_collocation_CORBA_Contained_Stub_Factory_function_pointer) (
+// Any operators for interface IR::TypedefDef
+TAO_Export void operator<<= (CORBA::Any &, IR::TypedefDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::TypedefDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::TypeDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::TypeDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::TypeDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::TypeDescription *&);
+extern TAO_Export IR::StructDef_ptr (*_TAO_collocation_IR_StructDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::Contained
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::Contained_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::Contained *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::Contained::Description &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::Contained::Description*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::Contained::Description *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::Contained::Description *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::InterfaceDefSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::InterfaceDefSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::InterfaceDefSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::InterfaceDefSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ValueDefSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ValueDefSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ValueDefSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ValueDefSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ContainedSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ContainedSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ContainedSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ContainedSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::StructMember &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::StructMember*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::StructMember *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::StructMember *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::StructMemberSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::StructMemberSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::StructMemberSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::StructMemberSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::Initializer &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::Initializer*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::Initializer *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::Initializer *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::InitializerSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::InitializerSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::InitializerSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::InitializerSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::UnionMember &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::UnionMember*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::UnionMember *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::UnionMember *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::UnionMemberSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::UnionMemberSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::UnionMemberSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::UnionMemberSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::EnumMemberSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::EnumMemberSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::EnumMemberSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::EnumMemberSeq *&);
-extern TAO_Export CORBA::Container_ptr (*_TAO_collocation_CORBA_Container_Stub_Factory_function_pointer) (
+// Any operators for interface IR::StructDef
+TAO_Export void operator<<= (CORBA::Any &, IR::StructDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::StructDef *&);
+extern TAO_Export IR::UnionDef_ptr (*_TAO_collocation_IR_UnionDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::Container
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::Container_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::Container *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::Container::Description &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::Container::Description*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::Container::Description *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::Container::Description *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::Container::DescriptionSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::Container::DescriptionSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::Container::DescriptionSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::Container::DescriptionSeq *&);
-extern TAO_Export CORBA::IDLType_ptr (*_TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer) (
+// Any operators for interface IR::UnionDef
+TAO_Export void operator<<= (CORBA::Any &, IR::UnionDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UnionDef *&);
+extern TAO_Export IR::EnumDef_ptr (*_TAO_collocation_IR_EnumDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::IDLType
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::IDLType_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::IDLType *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::PrimitiveKind);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::PrimitiveKind &);
-extern TAO_Export CORBA::Repository_ptr (*_TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer) (
+// Any operators for interface IR::EnumDef
+TAO_Export void operator<<= (CORBA::Any &, IR::EnumDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EnumDef *&);
+extern TAO_Export IR::AliasDef_ptr (*_TAO_collocation_IR_AliasDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::Repository
-TAO_Export void operator<<= (CORBA::Any &,
-                              CORBA::Repository_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::Repository *&);
-extern TAO_Export CORBA::ModuleDef_ptr (*_TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::AliasDef
+TAO_Export void operator<<= (CORBA::Any &, IR::AliasDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AliasDef *&);
+extern TAO_Export IR::NativeDef_ptr (*_TAO_collocation_IR_NativeDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::ModuleDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ModuleDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ModuleDef *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ModuleDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ModuleDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ModuleDescription *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ModuleDescription *&);
-extern TAO_Export CORBA::ConstantDef_ptr (*_TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::NativeDef
+TAO_Export void operator<<= (CORBA::Any &, IR::NativeDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::NativeDef *&);
+extern TAO_Export IR::PrimitiveDef_ptr (*_TAO_collocation_IR_PrimitiveDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::ConstantDef
-TAO_Export void operator<<= (CORBA::Any &,
-                              CORBA::ConstantDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ConstantDef *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ConstantDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ConstantDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ConstantDescription *&);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ConstantDescription *&);
-extern TAO_Export CORBA::TypedefDef_ptr (*_TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::PrimitiveDef
+TAO_Export void operator<<= (CORBA::Any &, IR::PrimitiveDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimitiveDef *&);
+extern TAO_Export IR::StringDef_ptr (*_TAO_collocation_IR_StringDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::TypedefDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::TypedefDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::TypedefDef *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::TypeDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::TypeDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::TypeDescription *&);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::TypeDescription *&);
-extern TAO_Export CORBA::StructDef_ptr (*_TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::StringDef
+TAO_Export void operator<<= (CORBA::Any &, IR::StringDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::StringDef *&);
+extern TAO_Export IR::WstringDef_ptr (*_TAO_collocation_IR_WstringDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::StructDef
-TAO_Export void  operator<<= (CORBA::Any &,
-                              CORBA::StructDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::StructDef *&);
-extern TAO_Export CORBA::UnionDef_ptr (*_TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::WstringDef
+TAO_Export void operator<<= (CORBA::Any &, IR::WstringDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::WstringDef *&);
+extern TAO_Export IR::FixedDef_ptr (*_TAO_collocation_IR_FixedDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::UnionDef
-TAO_Export void  operator<<= (CORBA::Any &, CORBA::UnionDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::UnionDef *&);
-extern TAO_Export CORBA::EnumDef_ptr (*_TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::FixedDef
+TAO_Export void operator<<= (CORBA::Any &, IR::FixedDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FixedDef *&);
+extern TAO_Export IR::SequenceDef_ptr (*_TAO_collocation_IR_SequenceDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::EnumDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::EnumDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::EnumDef *&);
-extern TAO_Export CORBA::AliasDef_ptr (*_TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::SequenceDef
+TAO_Export void operator<<= (CORBA::Any &, IR::SequenceDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::SequenceDef *&);
+extern TAO_Export IR::ArrayDef_ptr (*_TAO_collocation_IR_ArrayDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::AliasDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::AliasDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::AliasDef *&);
-extern TAO_Export CORBA::PrimitiveDef_ptr (*_TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::ArrayDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ArrayDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ArrayDef *&);
+extern TAO_Export IR::ExceptionDef_ptr (*_TAO_collocation_IR_ExceptionDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::PrimitiveDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::PrimitiveDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::PrimitiveDef *&);
-extern TAO_Export CORBA::StringDef_ptr (*_TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::ExceptionDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ExceptionDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ExceptionDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ExceptionDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ExceptionDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ExceptionDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ExceptionDescription *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ExceptionDefSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ExceptionDefSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ExceptionDefSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ExceptionDefSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ExcDescriptionSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ExcDescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ExcDescriptionSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ExcDescriptionSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, IR::AttributeMode);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AttributeMode &);
+extern TAO_Export IR::AttributeDef_ptr (*_TAO_collocation_IR_AttributeDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::StringDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::StringDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::StringDef *&);
-extern TAO_Export CORBA::WstringDef_ptr (*_TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::AttributeDef
+TAO_Export void operator<<= (CORBA::Any &, IR::AttributeDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AttributeDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::AttributeDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::AttributeDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AttributeDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::AttributeDescription *&);
+TAO_Export void operator<<= (CORBA::Any &, IR::OperationMode);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::OperationMode &);
+TAO_Export void operator<<= (CORBA::Any &, IR::ParameterMode);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ParameterMode &);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ParameterDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ParameterDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ParameterDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ParameterDescription *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ParDescriptionSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ParDescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ParDescriptionSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ParDescriptionSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ContextIdSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ContextIdSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ContextIdSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ContextIdSeq *&);
+extern TAO_Export IR::OperationDef_ptr (*_TAO_collocation_IR_OperationDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::WstringDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::WstringDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::WstringDef *&);
-extern TAO_Export CORBA::FixedDef_ptr (*_TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::OperationDef
+TAO_Export void operator<<= (CORBA::Any &, IR::OperationDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::OperationDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::OperationDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::OperationDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::OperationDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::OperationDescription *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::RepositoryIdSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::RepositoryIdSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::RepositoryIdSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::RepositoryIdSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::OpDescriptionSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::OpDescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::OpDescriptionSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::OpDescriptionSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::AttrDescriptionSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::AttrDescriptionSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::AttrDescriptionSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::AttrDescriptionSeq *&);
+extern TAO_Export IR::InterfaceDef_ptr (*_TAO_collocation_IR_InterfaceDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::FixedDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::FixedDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::FixedDef *&);
-extern TAO_Export CORBA::SequenceDef_ptr (*_TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::InterfaceDef
+TAO_Export void operator<<= (CORBA::Any &, IR::InterfaceDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::InterfaceDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::InterfaceDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::InterfaceDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::InterfaceDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::InterfaceDescription *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ValueMember &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ValueMember*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueMember *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ValueMember *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ValueMemberSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ValueMemberSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueMemberSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ValueMemberSeq *&);
+extern TAO_Export IR::ValueMemberDef_ptr (*_TAO_collocation_IR_ValueMemberDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::SequenceDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::SequenceDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::SequenceDef *&);
-extern TAO_Export CORBA::ArrayDef_ptr (*_TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::ValueMemberDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ValueMemberDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueMemberDef *&);
+extern TAO_Export IR::ValueDef_ptr (*_TAO_collocation_IR_ValueDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::ArrayDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ArrayDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ArrayDef *&);
-extern TAO_Export CORBA::ExceptionDef_ptr (*_TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::ValueDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ValueDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ValueDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ValueDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ValueDescription *&);
+extern TAO_Export IR::ValueBoxDef_ptr (*_TAO_collocation_IR_ValueBoxDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::ExceptionDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ExceptionDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ExceptionDef *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ExceptionDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ExceptionDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ExceptionDescription *&);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ExceptionDescription *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::AttributeMode);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::AttributeMode &);
-extern TAO_Export CORBA::AttributeDef_ptr (*_TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::ValueBoxDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ValueBoxDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ValueBoxDef *&);
+extern TAO_Export IR::ProvidesDef_ptr (*_TAO_collocation_IR_ProvidesDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::AttributeDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::AttributeDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::AttributeDef *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::AttributeDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::AttributeDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::AttributeDescription *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::AttributeDescription *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::OperationMode);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::OperationMode &);
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ParameterMode);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ParameterMode &);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ParameterDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ParameterDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ParameterDescription *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ParameterDescription *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ParDescriptionSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ParDescriptionSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ParDescriptionSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ParDescriptionSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ContextIdSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ContextIdSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ContextIdSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ContextIdSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ExceptionDefSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ExceptionDefSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ExceptionDefSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ExceptionDefSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ExcDescriptionSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ExcDescriptionSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ExcDescriptionSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ExcDescriptionSeq *&);
-extern TAO_Export CORBA::OperationDef_ptr (*_TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::ProvidesDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ProvidesDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ProvidesDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ProvidesDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ProvidesDescription *&);
+extern TAO_Export IR::UsesDef_ptr (*_TAO_collocation_IR_UsesDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::OperationDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::OperationDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::OperationDef *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::OperationDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::OperationDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::OperationDescription *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::OperationDescription *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::RepositoryIdSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::RepositoryIdSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::RepositoryIdSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::RepositoryIdSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::OpDescriptionSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::OpDescriptionSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::OpDescriptionSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::OpDescriptionSeq *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::AttrDescriptionSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::AttrDescriptionSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::AttrDescriptionSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::AttrDescriptionSeq *&);
-extern  CORBA::InterfaceDef_ptr (*_TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::UsesDef
+TAO_Export void operator<<= (CORBA::Any &, IR::UsesDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::UsesDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::UsesDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UsesDescription *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ProvidesDescSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ProvidesDescSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ProvidesDescSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ProvidesDescSeq *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::UsesDescSeq &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::UsesDescSeq*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::UsesDescSeq *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::UsesDescSeq *&);
+extern TAO_Export IR::EventDef_ptr (*_TAO_collocation_IR_EventDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::InterfaceDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::InterfaceDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::InterfaceDef *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::InterfaceDef::FullInterfaceDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::InterfaceDef::FullInterfaceDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::InterfaceDef::FullInterfaceDescription *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::InterfaceDef::FullInterfaceDescription *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::InterfaceDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::InterfaceDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::InterfaceDescription *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::InterfaceDescription *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ValueMember &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ValueMember*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ValueMember *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ValueMember *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ValueMemberSeq &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ValueMemberSeq*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ValueMemberSeq *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ValueMemberSeq *&);
-extern  CORBA::ValueMemberDef_ptr (*_TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::EventDef
+TAO_Export void operator<<= (CORBA::Any &, IR::EventDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EventDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::EventDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::EventDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EventDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::EventDescription *&);
+extern TAO_Export IR::EmitsDef_ptr (*_TAO_collocation_IR_EmitsDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::ValueMemberDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ValueMemberDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ValueMemberDef *&);
-extern  CORBA::ValueDef_ptr (*_TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::EmitsDef
+TAO_Export void operator<<= (CORBA::Any &, IR::EmitsDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::EmitsDef *&);
+extern TAO_Export IR::PublishesDef_ptr (*_TAO_collocation_IR_PublishesDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::ValueDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ValueDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ValueDef *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ValueDef::FullValueDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ValueDef::FullValueDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ValueDef::FullValueDescription *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ValueDef::FullValueDescription *&);
-TAO_Export void operator<<= (CORBA::Any &,
-                             const CORBA::ValueDescription &); // copying version
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ValueDescription*); // noncopying version
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ValueDescription *&); // deprecated
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       const CORBA::ValueDescription *&);
-extern  CORBA::ValueBoxDef_ptr (*_TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer) (
+// Any operators for interface IR::PublishesDef
+TAO_Export void operator<<= (CORBA::Any &, IR::PublishesDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PublishesDef *&);
+extern TAO_Export IR::ConsumesDef_ptr (*_TAO_collocation_IR_ConsumesDef_Stub_Factory_function_pointer) (
     CORBA::Object_ptr obj
   );
-// Any operators for interface CORBA::ValueBoxDef
-TAO_Export void operator<<= (CORBA::Any &,
-                             CORBA::ValueBoxDef_ptr);
-TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &,
-                                       CORBA::ValueBoxDef *&);
+// Any operators for interface IR::ConsumesDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ConsumesDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ConsumesDef *&);
+extern TAO_Export IR::ComponentDef_ptr (*_TAO_collocation_IR_ComponentDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::ComponentDef
+TAO_Export void operator<<= (CORBA::Any &, IR::ComponentDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::ComponentDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::ComponentDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::ComponentDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::ComponentDescription *&);
+extern TAO_Export IR::PrimaryKeyDef_ptr (*_TAO_collocation_IR_PrimaryKeyDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::PrimaryKeyDef
+TAO_Export void operator<<= (CORBA::Any &, IR::PrimaryKeyDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimaryKeyDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::PrimaryKeyDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::PrimaryKeyDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::PrimaryKeyDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::PrimaryKeyDescription *&);
+extern TAO_Export IR::FactoryDef_ptr (*_TAO_collocation_IR_FactoryDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::FactoryDef
+TAO_Export void operator<<= (CORBA::Any &, IR::FactoryDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FactoryDef *&);
+extern TAO_Export IR::FinderDef_ptr (*_TAO_collocation_IR_FinderDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::FinderDef
+TAO_Export void operator<<= (CORBA::Any &, IR::FinderDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::FinderDef *&);
+extern TAO_Export IR::HomeDef_ptr (*_TAO_collocation_IR_HomeDef_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface IR::HomeDef
+TAO_Export void operator<<= (CORBA::Any &, IR::HomeDef_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::HomeDef *&);
+TAO_Export void operator<<= (CORBA::Any &, const IR::HomeDescription &); // copying version
+TAO_Export void operator<<= (CORBA::Any &, IR::HomeDescription*); // noncopying version
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, IR::HomeDescription *&); // deprecated
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, const IR::HomeDescription *&);
+extern TAO_Export CORBA::TypeCodeFactory_ptr (*_TAO_collocation_CORBA_TypeCodeFactory_Stub_Factory_function_pointer) (
+    CORBA::Object_ptr obj
+  );
+// Any operators for interface CORBA::TypeCodeFactory
+TAO_Export void operator<<= (CORBA::Any &, CORBA::TypeCodeFactory_ptr);
+TAO_Export CORBA::Boolean operator>>= (const CORBA::Any &, CORBA::TypeCodeFactory *&);
 
 #ifndef __ACE_INLINE__
 
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::DefinitionKind &); //
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::DefinitionKind &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::IRObject_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::IRObject_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::Contained_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::Contained_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::Contained::Description &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::Contained::Description &);
-TAO_Export CORBA::Boolean  operator<< (
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::DefinitionKind &); // 
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::DefinitionKind &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Contained_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Contained_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Contained::Description &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Contained::Description &);
+
+#if !defined _TAO_CDR_OP_IR_InterfaceDefSeq_H_
+#define _TAO_CDR_OP_IR_InterfaceDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::InterfaceDefSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::InterfaceDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_InterfaceDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ValueDefSeq_H_
+#define _TAO_CDR_OP_IR_ValueDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::InterfaceDefSeq &
+    const IR::ValueDefSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::InterfaceDefSeq &
+    IR::ValueDefSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_ValueDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ComponentDefSeq_H_
+#define _TAO_CDR_OP_IR_ComponentDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::ValueDefSeq &
+    const IR::ComponentDefSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::ValueDefSeq &
+    IR::ComponentDefSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_ComponentDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ProvidesDefSeq_H_
+#define _TAO_CDR_OP_IR_ProvidesDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::ContainedSeq &
+    const IR::ProvidesDefSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::ContainedSeq &
+    IR::ProvidesDefSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::StructMember &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::StructMember &);
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_ProvidesDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_UsesDefSeq_H_
+#define _TAO_CDR_OP_IR_UsesDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::UsesDefSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::UsesDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_UsesDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_HomeDefSeq_H_
+#define _TAO_CDR_OP_IR_HomeDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::HomeDefSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::HomeDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_HomeDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_EmitsDefSeq_H_
+#define _TAO_CDR_OP_IR_EmitsDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::StructMemberSeq &
+    const IR::EmitsDefSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::StructMemberSeq &
+    IR::EmitsDefSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::Initializer &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::Initializer &);
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_EmitsDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_PublishesDefSeq_H_
+#define _TAO_CDR_OP_IR_PublishesDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::InitializerSeq &
+    const IR::PublishesDefSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::InitializerSeq &
+    IR::PublishesDefSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::UnionMember &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::UnionMember &);
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_PublishesDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ConsumesDefSeq_H_
+#define _TAO_CDR_OP_IR_ConsumesDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::UnionMemberSeq &
+    const IR::ConsumesDefSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::UnionMemberSeq &
+    IR::ConsumesDefSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_ConsumesDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_FactoryDefSeq_H_
+#define _TAO_CDR_OP_IR_FactoryDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::EnumMemberSeq &
+    const IR::FactoryDefSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::EnumMemberSeq &
+    IR::FactoryDefSeq &
   );
 
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::Container_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::Container_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::Container::Description &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::Container::Description &);
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_FactoryDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_FinderDefSeq_H_
+#define _TAO_CDR_OP_IR_FinderDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::Container::DescriptionSeq &
+    const IR::FinderDefSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::Container::DescriptionSeq &
+    IR::FinderDefSeq &
   );
 
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::IDLType_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::IDLType_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::PrimitiveKind &); //
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::PrimitiveKind &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::Repository_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::Repository_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::ModuleDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::ModuleDef_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ModuleDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ModuleDescription &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::ConstantDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::ConstantDef_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ConstantDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ConstantDescription &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::TypedefDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::TypedefDef_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::TypeDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::TypeDescription &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::StructDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::StructDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::UnionDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::UnionDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::EnumDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::EnumDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::AliasDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::AliasDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::PrimitiveDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::PrimitiveDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::StringDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::StringDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::WstringDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::WstringDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::FixedDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::FixedDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::SequenceDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::SequenceDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::ArrayDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::ArrayDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::ExceptionDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::ExceptionDef_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ExceptionDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ExceptionDescription &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::AttributeMode &); //
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::AttributeMode &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::AttributeDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::AttributeDef_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::AttributeDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::AttributeDescription &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::OperationMode &); //
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::OperationMode &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ParameterMode &); //
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ParameterMode &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ParameterDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ParameterDescription &);
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_FinderDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ContainedSeq_H_
+#define _TAO_CDR_OP_IR_ContainedSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::ParDescriptionSeq &
+    const IR::ContainedSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::ParDescriptionSeq &
+    IR::ContainedSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_ContainedSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::StructMember &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::StructMember &);
+
+#if !defined _TAO_CDR_OP_IR_StructMemberSeq_H_
+#define _TAO_CDR_OP_IR_StructMemberSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::ContextIdSeq &
+    const IR::StructMemberSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::ContextIdSeq &
+    IR::StructMemberSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_StructMemberSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Initializer &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Initializer &);
+
+#if !defined _TAO_CDR_OP_IR_InitializerSeq_H_
+#define _TAO_CDR_OP_IR_InitializerSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::ExceptionDefSeq &
+    const IR::InitializerSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::ExceptionDefSeq &
+    IR::InitializerSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_InitializerSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UnionMember &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UnionMember &);
+
+#if !defined _TAO_CDR_OP_IR_UnionMemberSeq_H_
+#define _TAO_CDR_OP_IR_UnionMemberSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::ExcDescriptionSeq &
+    const IR::UnionMemberSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::ExcDescriptionSeq &
+    IR::UnionMemberSeq &
   );
 
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::OperationDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::OperationDef_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::OperationDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::OperationDescription &);
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_UnionMemberSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_EnumMemberSeq_H_
+#define _TAO_CDR_OP_IR_EnumMemberSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::RepositoryIdSeq &
+    const IR::EnumMemberSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::RepositoryIdSeq &
+    IR::EnumMemberSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_EnumMemberSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Container_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Container_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Container::Description &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Container::Description &);
+
+#if !defined _TAO_CDR_OP_IR_Container_DescriptionSeq_H_
+#define _TAO_CDR_OP_IR_Container_DescriptionSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::OpDescriptionSeq &
+    const IR::Container::DescriptionSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::OpDescriptionSeq &
+    IR::Container::DescriptionSeq &
   );
 
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_Container_DescriptionSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::IDLType_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::IDLType_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimitiveKind &); // 
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimitiveKind &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::Repository_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::Repository_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ComponentRepository_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ComponentRepository_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ModuleDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ModuleDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ModuleDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ModuleDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ConstantDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ConstantDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ConstantDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ConstantDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::TypedefDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::TypedefDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::TypeDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::TypeDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::StructDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::StructDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UnionDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UnionDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EnumDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EnumDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::AliasDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::AliasDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::NativeDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::NativeDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimitiveDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimitiveDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::StringDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::StringDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::WstringDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::WstringDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::FixedDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::FixedDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::SequenceDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::SequenceDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ArrayDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ArrayDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ExceptionDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ExceptionDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ExceptionDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ExceptionDescription &);
+
+#if !defined _TAO_CDR_OP_IR_ExceptionDefSeq_H_
+#define _TAO_CDR_OP_IR_ExceptionDefSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::AttrDescriptionSeq &
+    const IR::ExceptionDefSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::AttrDescriptionSeq &
+    IR::ExceptionDefSeq &
   );
 
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::InterfaceDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::InterfaceDef_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::InterfaceDef::FullInterfaceDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::InterfaceDef::FullInterfaceDescription &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::InterfaceDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::InterfaceDescription &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ValueMember &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ValueMember &);
-TAO_Export CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_ExceptionDefSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ExcDescriptionSeq_H_
+#define _TAO_CDR_OP_IR_ExcDescriptionSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::ExcDescriptionSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::ExcDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ExcDescriptionSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::AttributeMode &); // 
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::AttributeMode &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::AttributeDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::AttributeDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::AttributeDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::AttributeDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::OperationMode &); // 
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::OperationMode &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ParameterMode &); // 
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ParameterMode &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ParameterDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ParameterDescription &);
+
+#if !defined _TAO_CDR_OP_IR_ParDescriptionSeq_H_
+#define _TAO_CDR_OP_IR_ParDescriptionSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::ParDescriptionSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::ParDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ParDescriptionSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ContextIdSeq_H_
+#define _TAO_CDR_OP_IR_ContextIdSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::ContextIdSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::ContextIdSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ContextIdSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::OperationDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::OperationDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::OperationDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::OperationDescription &);
+
+#if !defined _TAO_CDR_OP_IR_RepositoryIdSeq_H_
+#define _TAO_CDR_OP_IR_RepositoryIdSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::RepositoryIdSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::RepositoryIdSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_RepositoryIdSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_OpDescriptionSeq_H_
+#define _TAO_CDR_OP_IR_OpDescriptionSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::OpDescriptionSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::OpDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_OpDescriptionSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_AttrDescriptionSeq_H_
+#define _TAO_CDR_OP_IR_AttrDescriptionSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::AttrDescriptionSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::AttrDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_AttrDescriptionSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::InterfaceDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::InterfaceDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::InterfaceDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::InterfaceDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueMember &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueMember &);
+
+#if !defined _TAO_CDR_OP_IR_ValueMemberSeq_H_
+#define _TAO_CDR_OP_IR_ValueMemberSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::ValueMemberSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::ValueMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ValueMemberSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueMemberDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueMemberDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ValueBoxDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ValueBoxDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ProvidesDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ProvidesDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ProvidesDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ProvidesDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UsesDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UsesDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::UsesDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::UsesDescription &);
+
+#if !defined _TAO_CDR_OP_IR_ProvidesDescSeq_H_
+#define _TAO_CDR_OP_IR_ProvidesDescSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
+    TAO_OutputCDR &,
+    const IR::ProvidesDescSeq &
+  );
+TAO_Export CORBA::Boolean operator>> (
+    TAO_InputCDR &,
+    IR::ProvidesDescSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ProvidesDescSeq_H_ */
+
+
+#if !defined _TAO_CDR_OP_IR_UsesDescSeq_H_
+#define _TAO_CDR_OP_IR_UsesDescSeq_H_
+
+TAO_Export CORBA::Boolean operator<< (
     TAO_OutputCDR &,
-    const CORBA::ValueMemberSeq &
+    const IR::UsesDescSeq &
   );
-TAO_Export CORBA::Boolean  operator>> (
+TAO_Export CORBA::Boolean operator>> (
     TAO_InputCDR &,
-    CORBA::ValueMemberSeq &
+    IR::UsesDescSeq &
   );
 
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::ValueMemberDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::ValueMemberDef_ptr &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::ValueDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::ValueDef_ptr &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ValueDef::FullValueDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ValueDef::FullValueDescription &);
-TAO_Export CORBA::Boolean  operator<< (TAO_OutputCDR &, const CORBA::ValueDescription &);
-TAO_Export CORBA::Boolean  operator>> (TAO_InputCDR &, CORBA::ValueDescription &);
-TAO_Export CORBA::Boolean
-operator<< (TAO_OutputCDR &, const CORBA::ValueBoxDef_ptr );
-TAO_Export CORBA::Boolean
-operator>> (TAO_InputCDR &, CORBA::ValueBoxDef_ptr &);
+#endif /* _TAO_CDR_OP_IR_UsesDescSeq_H_ */
+
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EventDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EventDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EventDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EventDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::EmitsDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::EmitsDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PublishesDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PublishesDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ConsumesDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ConsumesDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ComponentDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ComponentDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::ComponentDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::ComponentDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimaryKeyDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimaryKeyDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::PrimaryKeyDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::PrimaryKeyDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::FactoryDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::FactoryDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::FinderDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::FinderDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::HomeDef_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::HomeDef_ptr &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const IR::HomeDescription &);
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, IR::HomeDescription &);
+TAO_Export CORBA::Boolean operator<< (TAO_OutputCDR &, const CORBA::TypeCodeFactory_ptr );
+TAO_Export CORBA::Boolean operator>> (TAO_InputCDR &, CORBA::TypeCodeFactory_ptr &);
 
 #endif /* __ACE_INLINE__ */
 
 
 #if defined (__ACE_INLINE__)
-#include "tao/InterfaceC.i"
+#include "InterfaceC.i"
 #endif /* defined INLINE */
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
diff --git a/TAO/tao/InterfaceC.i b/TAO/tao/InterfaceC.i
index ddaa35c812f..67cf9842626 100644
--- a/TAO/tao/InterfaceC.i
+++ b/TAO/tao/InterfaceC.i
@@ -196,116 +196,116 @@ CORBA_IRObject_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_Contained::CORBA_Contained (void) // default constructor
+IR::Contained::Contained (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_Contained::CORBA_Contained (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::Contained::Contained (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_Contained::~CORBA_Contained (void) // destructor
+IR::Contained::~Contained (void) // destructor
 {}
 
 
-#if !defined (_CORBA_CONTAINED___VAR_CI_)
-#define _CORBA_CONTAINED___VAR_CI_
+#if !defined (_IR_CONTAINED___VAR_CI_)
+#define _IR_CONTAINED___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA::Contained_var
+// Inline operations for class IR::Contained_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_Contained_var::CORBA_Contained_var (void) // default constructor
-  : ptr_ (CORBA::Contained::_nil ())
+IR::Contained_var::Contained_var (void) // default constructor
+  : ptr_ (Contained::_nil ())
 {}
 
 ACE_INLINE
-CORBA_Contained_var::CORBA_Contained_var (CORBA::Contained_ptr p)
+IR::Contained_var::Contained_var (Contained_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_Contained_ptr 
-CORBA_Contained_var::ptr (void) const
+ACE_INLINE ::IR::Contained_ptr
+IR::Contained_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_Contained_var::CORBA_Contained_var (const CORBA::Contained_var &p) // copy constructor
-  : ptr_ (CORBA::Contained::_duplicate (p.ptr ()))
+IR::Contained_var::Contained_var (const ::IR::Contained_var &p) // copy constructor
+  : ptr_ (Contained::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_Contained_var::~CORBA_Contained_var (void) // destructor
+IR::Contained_var::~Contained_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_Contained_var &
-CORBA_Contained_var::operator= (CORBA::Contained_ptr p)
+ACE_INLINE IR::Contained_var &
+IR::Contained_var::operator= (Contained_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_Contained_var &
-CORBA_Contained_var::operator= (const CORBA::Contained_var &p)
+ACE_INLINE IR::Contained_var &
+IR::Contained_var::operator= (const ::IR::Contained_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA::Contained::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::Contained::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Contained_var::operator const CORBA::Contained_ptr &() const // cast
+IR::Contained_var::operator const ::IR::Contained_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_Contained_var::operator CORBA_Contained_ptr &() // cast 
+IR::Contained_var::operator ::IR::Contained_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained_ptr 
-CORBA_Contained_var::operator-> (void) const
+ACE_INLINE ::IR::Contained_ptr
+IR::Contained_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained_ptr
-CORBA_Contained_var::in (void) const
+ACE_INLINE ::IR::Contained_ptr
+IR::Contained_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained_ptr &
-CORBA_Contained_var::inout (void)
+ACE_INLINE ::IR::Contained_ptr &
+IR::Contained_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained_ptr &
-CORBA_Contained_var::out (void)
+ACE_INLINE ::IR::Contained_ptr &
+IR::Contained_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA::Contained::_nil ();
+  this->ptr_ = ::IR::Contained::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained_ptr 
-CORBA_Contained_var::_retn (void)
+ACE_INLINE ::IR::Contained_ptr
+IR::Contained_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA::Contained_ptr val = this->ptr_;
-  this->ptr_ = CORBA::Contained::_nil ();
+  ::IR::Contained_ptr val = this->ptr_;
+  this->ptr_ = ::IR::Contained::_nil ();
   return val;
 }
 
@@ -313,68 +313,68 @@ CORBA_Contained_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINED___OUT_CI_)
-#define _CORBA_CONTAINED___OUT_CI_
+#if !defined (_IR_CONTAINED___OUT_CI_)
+#define _IR_CONTAINED___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA::Contained_out
+// Inline operations for class IR::Contained_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_Contained_out::CORBA_Contained_out (CORBA_Contained_ptr &p)
+IR::Contained_out::Contained_out (Contained_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA::Contained::_nil ();
+  this->ptr_ = ::IR::Contained::_nil ();
 }
 
 ACE_INLINE
-CORBA_Contained_out::CORBA_Contained_out (CORBA_Contained_var &p) // constructor from _var
+IR::Contained_out::Contained_out (Contained_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA::Contained::_nil ();
+  this->ptr_ = ::IR::Contained::_nil ();
 }
 
 ACE_INLINE
-CORBA_Contained_out::CORBA_Contained_out (const CORBA_Contained_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA::Contained_out&,p).ptr_)
+IR::Contained_out::Contained_out (const ::IR::Contained_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (Contained_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_Contained_out &
-CORBA_Contained_out::operator= (const CORBA_Contained_out &p)
+ACE_INLINE ::IR::Contained_out &
+IR::Contained_out::operator= (const ::IR::Contained_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_Contained_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (Contained_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_Contained_out &
-CORBA_Contained_out::operator= (const CORBA_Contained_var &p)
+ACE_INLINE IR::Contained_out &
+IR::Contained_out::operator= (const ::IR::Contained_var &p)
 {
-  this->ptr_ = CORBA_Contained::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::Contained::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_Contained_out &
-CORBA_Contained_out::operator= (CORBA_Contained_ptr p)
+ACE_INLINE IR::Contained_out &
+IR::Contained_out::operator= (Contained_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Contained_out::operator CORBA_Contained_ptr &() // cast
+IR::Contained_out::operator ::IR::Contained_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained_ptr &
-CORBA_Contained_out::ptr (void) // ptr
+ACE_INLINE ::IR::Contained_ptr &
+IR::Contained_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained_ptr 
-CORBA_Contained_out::operator-> (void)
+ACE_INLINE ::IR::Contained_ptr
+IR::Contained_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -383,134 +383,479 @@ CORBA_Contained_out::operator-> (void)
 #endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA::Contained::Description_var
+// Inline operations for class IR::Contained::Description_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_Contained::Description_var::Description_var (void) // default constructor
+IR::Contained::Description_var::Description_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_Contained::Description_var::Description_var (CORBA_Contained::Description *p)
+IR::Contained::Description_var::Description_var (Description *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_Contained::Description_var::Description_var (const CORBA_Contained::Description_var &p) // copy constructor
+IR::Contained::Description_var::Description_var (const ::IR::Contained::Description_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_Contained::Description(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::Contained::Description (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_Contained::Description_var::~Description_var (void) // destructor
+IR::Contained::Description_var::~Description_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained::Description_var &
-CORBA_Contained::Description_var::operator= (CORBA_Contained::Description *p)
+ACE_INLINE IR::Contained::Description_var &
+IR::Contained::Description_var::operator= (Description *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_Contained::Description_var &
-CORBA_Contained::Description_var::operator= (const CORBA_Contained::Description_var &p)
+ACE_INLINE ::IR::Contained::Description_var &
+IR::Contained::Description_var::operator= (const ::IR::Contained::Description_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_Contained::Description (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::Contained::Description (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_Contained::Description *
-CORBA_Contained::Description_var::operator-> (void) const
+ACE_INLINE const ::IR::Contained::Description *
+IR::Contained::Description_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained::Description *
-CORBA_Contained::Description_var::operator-> (void)
+ACE_INLINE ::IR::Contained::Description *
+IR::Contained::Description_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::Contained::Description_var::operator const ::IR::Contained::Description &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::Contained::Description_var::operator ::IR::Contained::Description &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::Contained::Description_var::operator ::IR::Contained::Description &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::Contained::Description_var::operator ::IR::Contained::Description *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::Contained::Description &
+IR::Contained::Description_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::Contained::Description &
+IR::Contained::Description_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::Contained::Description *&
+IR::Contained::Description_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::Contained::Description *
+IR::Contained::Description_var::_retn (void)
+{
+  ::IR::Contained::Description *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::Contained::Description *
+IR::Contained::Description_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::Contained::Description_out
+// *************************************************************
+
+ACE_INLINE
+IR::Contained::Description_out::Description_out (::IR::Contained::Description *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::Contained::Description_out::Description_out (Description_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::Contained::Description_out::Description_out (const ::IR::Contained::Description_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (Description_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::Contained::Description_out &
+IR::Contained::Description_out::operator= (const ::IR::Contained::Description_out &p)
+{
+  this->ptr_ = ACE_const_cast (Description_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::Contained::Description_out &
+IR::Contained::Description_out::operator= (Description *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::Contained::Description_out::operator ::IR::Contained::Description *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::Contained::Description *&
+IR::Contained::Description_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::Contained::Description *
+IR::Contained::Description_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_INTERFACEDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_INTERFACEDEFSEQ_CI_
+
+  ACE_INLINE IR::InterfaceDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::InterfaceDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::InterfaceDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::InterfaceDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::freebuf (IR::InterfaceDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::InterfaceDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::InterfaceDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (this->maximum_);
+      IR::InterfaceDef ** const tmp2 = ACE_reinterpret_cast (IR::InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::InterfaceDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::InterfaceDef **tmp = ACE_reinterpret_cast (IR::InterfaceDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::InterfaceDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::InterfaceDef **tmp1 = ACE_reinterpret_cast (IR::InterfaceDef **, this->buffer_);
+    IR::InterfaceDef ** const tmp2 = ACE_reinterpret_cast (IR::InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::InterfaceDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::InterfaceDef,IR::InterfaceDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::InterfaceDef ** const tmp = ACE_reinterpret_cast (IR::InterfaceDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::InterfaceDef,IR::InterfaceDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::InterfaceDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::InterfaceDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::InterfaceDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::InterfaceDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::InterfaceDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_InterfaceDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::InterfaceDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_INTERFACEDEFSEQ_CI_)
+#define _IR_INTERFACEDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::InterfaceDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::InterfaceDefSeq_var::InterfaceDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::InterfaceDefSeq_var::InterfaceDefSeq_var (InterfaceDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::InterfaceDefSeq_var::InterfaceDefSeq_var (const ::IR::InterfaceDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::InterfaceDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::InterfaceDefSeq_var::~InterfaceDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::InterfaceDefSeq_var &
+IR::InterfaceDefSeq_var::operator= (InterfaceDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::InterfaceDefSeq_var &
+IR::InterfaceDefSeq_var::operator= (const ::IR::InterfaceDefSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::InterfaceDefSeq (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::InterfaceDefSeq *
+IR::InterfaceDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::InterfaceDefSeq *
+IR::InterfaceDefSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_Contained::Description_var::operator const CORBA_Contained::Description &() const // cast
+IR::InterfaceDefSeq_var::operator const ::IR::InterfaceDefSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_Contained::Description_var::operator CORBA_Contained::Description &() // cast 
+IR::InterfaceDefSeq_var::operator ::IR::InterfaceDefSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_Contained::Description_var::operator CORBA_Contained::Description &() const// cast 
+IR::InterfaceDefSeq_var::operator ::IR::InterfaceDefSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_Contained::Description &
-CORBA_Contained::Description_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::InterfaceDefSeq_var::operator ::IR::InterfaceDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::InterfaceDef, IR::InterfaceDef_var> 
+IR::InterfaceDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::InterfaceDefSeq &
+IR::InterfaceDefSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained::Description &
-CORBA_Contained::Description_var::inout (void)
+ACE_INLINE ::IR::InterfaceDefSeq &
+IR::InterfaceDefSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_Contained::Description *&
-CORBA_Contained::Description_var::out (void)
+ACE_INLINE ::IR::InterfaceDefSeq *&
+IR::InterfaceDefSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained::Description *
-CORBA_Contained::Description_var::_retn (void)
+ACE_INLINE ::IR::InterfaceDefSeq *
+IR::InterfaceDefSeq_var::_retn (void)
 {
-  CORBA_Contained::Description *tmp = this->ptr_;
+  ::IR::InterfaceDefSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_Contained::Description *
-CORBA_Contained::Description_var::ptr (void) const
+ACE_INLINE ::IR::InterfaceDefSeq *
+IR::InterfaceDefSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA::Contained::Description_out
+// Inline operations for class IR::InterfaceDefSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_Contained::Description_out::Description_out (CORBA_Contained::Description *&p)
+IR::InterfaceDefSeq_out::InterfaceDefSeq_out (InterfaceDefSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_Contained::Description_out::Description_out (CORBA_Contained::Description_var &p) // constructor from _var
+IR::InterfaceDefSeq_out::InterfaceDefSeq_out (InterfaceDefSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -518,65 +863,72 @@ CORBA_Contained::Description_out::Description_out (CORBA_Contained::Description_
 }
 
 ACE_INLINE
-CORBA_Contained::Description_out::Description_out (const CORBA_Contained::Description_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_Contained::Description_out&,p).ptr_)
+IR::InterfaceDefSeq_out::InterfaceDefSeq_out (const ::IR::InterfaceDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (InterfaceDefSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_Contained::Description_out &
-CORBA_Contained::Description_out::operator= (const CORBA_Contained::Description_out &p)
+ACE_INLINE ::IR::InterfaceDefSeq_out &
+IR::InterfaceDefSeq_out::operator= (const ::IR::InterfaceDefSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_Contained::Description_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (InterfaceDefSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_Contained::Description_out &
-CORBA_Contained::Description_out::operator= (CORBA_Contained::Description *p)
+ACE_INLINE ::IR::InterfaceDefSeq_out &
+IR::InterfaceDefSeq_out::operator= (InterfaceDefSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Contained::Description_out::operator CORBA_Contained::Description *&() // cast
+IR::InterfaceDefSeq_out::operator ::IR::InterfaceDefSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained::Description *&
-CORBA_Contained::Description_out::ptr (void) // ptr
+ACE_INLINE ::IR::InterfaceDefSeq *&
+IR::InterfaceDefSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Contained::Description *
-CORBA_Contained::Description_out::operator-> (void)
+ACE_INLINE ::IR::InterfaceDefSeq *
+IR::InterfaceDefSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
+ACE_INLINE TAO_Object_Manager<IR::InterfaceDef, IR::InterfaceDef_var> 
+IR::InterfaceDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CI_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_INTERFACEDEFSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_VALUEDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_VALUEDEFSEQ_CI_
 
-  ACE_INLINE CORBA_InterfaceDef **
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (CORBA::ULong nelems)
+  ACE_INLINE IR::ValueDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (CORBA::ULong nelems)
   {
-    CORBA::InterfaceDef **buf = 0;
+    IR::ValueDef **buf = 0;
     
-    ACE_NEW_RETURN (buf, 
-                    CORBA::InterfaceDef*[nelems], 
-		    0);
+    ACE_NEW_RETURN (buf, IR::ValueDef*[nelems], 0);
     
     for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = CORBA::InterfaceDef::_nil ();
+      buf[i] = IR::ValueDef::_nil ();
     
     return buf;
   }
   
   ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (CORBA::InterfaceDef **buffer)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::freebuf (IR::ValueDef **buffer)
   {
     if (buffer == 0)
       return;
@@ -584,97 +936,454 @@ CORBA_Contained::Description_out::operator-> (void)
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (void)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (void)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA::InterfaceDef* *value,
+    IR::ValueDef* *value,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &rhs)
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA::InterfaceDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (this->maximum_);
-    CORBA::InterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+    if (rhs.buffer_ != 0)
+    {
+      IR::ValueDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (this->maximum_);
+      IR::ValueDef ** const tmp2 = ACE_reinterpret_cast (IR::ValueDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::ValueDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::ValueDef **tmp = ACE_reinterpret_cast (IR::ValueDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::ValueDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::ValueDef **tmp1 = ACE_reinterpret_cast (IR::ValueDef **, this->buffer_);
+    IR::ValueDef ** const tmp2 = ACE_reinterpret_cast (IR::ValueDef ** ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = CORBA::InterfaceDef::_duplicate (tmp2[i]);
+      tmp1[i] = IR::ValueDef::_duplicate (tmp2[i]);
     
-    this->buffer_ = tmp1;
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::ValueDef,IR::ValueDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::ValueDef ** const tmp = ACE_reinterpret_cast (IR::ValueDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::ValueDef,IR::ValueDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::ValueDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::ValueDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::ValueDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::ValueDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::ValueDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ValueDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::ValueDef ** ACE_CAST_CONST, this->buffer_);
   }
   
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq &rhs)
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_VALUEDEFSEQ_CI_)
+#define _IR_VALUEDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::ValueDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::ValueDefSeq_var::ValueDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ValueDefSeq_var::ValueDefSeq_var (ValueDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::ValueDefSeq_var::ValueDefSeq_var (const ::IR::ValueDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ValueDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ValueDefSeq_var::~ValueDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ValueDefSeq_var &
+IR::ValueDefSeq_var::operator= (ValueDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ValueDefSeq_var &
+IR::ValueDefSeq_var::operator= (const ::IR::ValueDefSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::ValueDefSeq (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::ValueDefSeq *
+IR::ValueDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDefSeq *
+IR::ValueDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ValueDefSeq_var::operator const ::IR::ValueDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ValueDefSeq_var::operator ::IR::ValueDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ValueDefSeq_var::operator ::IR::ValueDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ValueDefSeq_var::operator ::IR::ValueDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ValueDef, IR::ValueDef_var> 
+IR::ValueDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::ValueDefSeq &
+IR::ValueDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDefSeq &
+IR::ValueDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ValueDefSeq *&
+IR::ValueDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDefSeq *
+IR::ValueDefSeq_var::_retn (void)
+{
+  ::IR::ValueDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ValueDefSeq *
+IR::ValueDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ValueDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::ValueDefSeq_out::ValueDefSeq_out (ValueDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ValueDefSeq_out::ValueDefSeq_out (ValueDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ValueDefSeq_out::ValueDefSeq_out (const ::IR::ValueDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ValueDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ValueDefSeq_out &
+IR::ValueDefSeq_out::operator= (const ::IR::ValueDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (ValueDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::ValueDefSeq_out &
+IR::ValueDefSeq_out::operator= (ValueDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ValueDefSeq_out::operator ::IR::ValueDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDefSeq *&
+IR::ValueDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDefSeq *
+IR::ValueDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ValueDef, IR::ValueDef_var> 
+IR::ValueDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_COMPONENTDEFSEQ_CI_
+
+  ACE_INLINE IR::ComponentDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::ComponentDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::ComponentDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::ComponentDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::freebuf (IR::ComponentDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::ComponentDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::ComponentDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (this->maximum_);
+      IR::ComponentDef ** const tmp2 = ACE_reinterpret_cast (IR::ComponentDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::ComponentDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq &rhs)
   {
     if (this == &rhs)
       return *this;
     
     if (this->release_)
     {
-      CORBA::InterfaceDef **tmp = ACE_reinterpret_cast (CORBA::InterfaceDef **, this->buffer_);
+      IR::ComponentDef **tmp = ACE_reinterpret_cast (IR::ComponentDef **, this->buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
       {
         CORBA::release (tmp[i]);
-        tmp[i] = CORBA::InterfaceDef::_nil ();
+        tmp[i] = IR::ComponentDef::_nil ();
       }
       if (this->maximum_ < rhs.maximum_)
       {
-        _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (rhs.maximum_);
+        _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA::InterfaceDef **tmp1 = ACE_reinterpret_cast (CORBA::InterfaceDef **, this->buffer_);
-    CORBA::InterfaceDef ** const tmp2 = ACE_reinterpret_cast (CORBA::InterfaceDef ** ACE_CAST_CONST, rhs.buffer_);
+    IR::ComponentDef **tmp1 = ACE_reinterpret_cast (IR::ComponentDef **, this->buffer_);
+    IR::ComponentDef ** const tmp2 = ACE_reinterpret_cast (IR::ComponentDef ** ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = CORBA::InterfaceDef::_duplicate (tmp2[i]);
+      tmp1[i] = IR::ComponentDef::_duplicate (tmp2[i]);
     
     return *this;
   }
   
-  ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var>
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::operator[] (CORBA::ULong index) const
+  ACE_INLINE TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::operator[] (CORBA::ULong index) const
   // read-write accessor
   {
     ACE_ASSERT (index < this->maximum_);
-    CORBA::InterfaceDef ** const tmp = ACE_reinterpret_cast (CORBA::InterfaceDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> (tmp + index, this->release_);
+    IR::ComponentDef ** const tmp = ACE_reinterpret_cast (IR::ComponentDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::ComponentDef,IR::ComponentDef_var> (tmp + index, this->release_);
   }
   
-  ACE_INLINE CORBA::InterfaceDef* *
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::ComponentDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA::InterfaceDef **result = 0;
+    IR::ComponentDef **result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::allocbuf (this->maximum_);
+        result = _TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::allocbuf (this->maximum_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA::InterfaceDef**, this->buffer_);
+        result = ACE_reinterpret_cast (IR::ComponentDef**, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -683,7 +1392,7 @@ CORBA_Contained::Description_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA::InterfaceDef**,this->buffer_);
+        result = ACE_reinterpret_cast(IR::ComponentDef**,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -693,10 +1402,10 @@ CORBA_Contained::Description_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const CORBA::InterfaceDef* *
-  _TAO_Unbounded_Object_Sequence_CORBA_InterfaceDefSeq::get_buffer (void) const
+  ACE_INLINE const IR::ComponentDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ComponentDefSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA::InterfaceDef ** ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::ComponentDef ** ACE_CAST_CONST, this->buffer_);
   }
   
   
@@ -705,144 +1414,148 @@ CORBA_Contained::Description_out::operator-> (void)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_INTERFACEDEFSEQ_CI_)
-#define _CORBA_INTERFACEDEFSEQ_CI_
+#if !defined (_IR_COMPONENTDEFSEQ_CI_)
+#define _IR_COMPONENTDEFSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA::InterfaceDefSeq_var
+// Inline operations for class IR::ComponentDefSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_InterfaceDefSeq_var::CORBA_InterfaceDefSeq_var (void) // default constructor
+IR::ComponentDefSeq_var::ComponentDefSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_InterfaceDefSeq_var::CORBA_InterfaceDefSeq_var (CORBA::InterfaceDefSeq *p)
+IR::ComponentDefSeq_var::ComponentDefSeq_var (ComponentDefSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_InterfaceDefSeq_var::CORBA_InterfaceDefSeq_var (const CORBA_InterfaceDefSeq_var &p) // copy constructor
+IR::ComponentDefSeq_var::ComponentDefSeq_var (const ::IR::ComponentDefSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA::InterfaceDefSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ComponentDefSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_InterfaceDefSeq_var::~CORBA_InterfaceDefSeq_var (void) // destructor
+IR::ComponentDefSeq_var::~ComponentDefSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDefSeq_var &
-CORBA_InterfaceDefSeq_var::operator= (CORBA::InterfaceDefSeq *p)
+ACE_INLINE IR::ComponentDefSeq_var &
+IR::ComponentDefSeq_var::operator= (ComponentDefSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_InterfaceDefSeq_var &
-CORBA_InterfaceDefSeq_var::operator= (const CORBA::InterfaceDefSeq_var &p) // deep copy
+ACE_INLINE IR::ComponentDefSeq_var &
+IR::ComponentDefSeq_var::operator= (const ::IR::ComponentDefSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA::InterfaceDefSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ComponentDefSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_InterfaceDefSeq *
-CORBA_InterfaceDefSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDefSeq *
-CORBA_InterfaceDefSeq_var::operator-> (void)
+ACE_INLINE ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_InterfaceDefSeq_var::operator const CORBA::InterfaceDefSeq &() const // cast
+IR::ComponentDefSeq_var::operator const ::IR::ComponentDefSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_InterfaceDefSeq_var::operator CORBA_InterfaceDefSeq &() // cast 
+IR::ComponentDefSeq_var::operator ::IR::ComponentDefSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_InterfaceDefSeq_var::operator CORBA::InterfaceDefSeq &() const// cast 
+IR::ComponentDefSeq_var::operator ::IR::ComponentDefSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> 
-CORBA_InterfaceDefSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::ComponentDefSeq_var::operator ::IR::ComponentDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ComponentDef, IR::ComponentDef_var> 
+IR::ComponentDefSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_InterfaceDefSeq &
-CORBA_InterfaceDefSeq_var::in (void) const
+ACE_INLINE const ::IR::ComponentDefSeq &
+IR::ComponentDefSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDefSeq &
-CORBA_InterfaceDefSeq_var::inout (void)
+ACE_INLINE ::IR::ComponentDefSeq &
+IR::ComponentDefSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_InterfaceDefSeq *&
-CORBA_InterfaceDefSeq_var::out (void)
+ACE_INLINE ::IR::ComponentDefSeq *&
+IR::ComponentDefSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDefSeq *
-CORBA_InterfaceDefSeq_var::_retn (void)
+ACE_INLINE ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_var::_retn (void)
 {
-  CORBA::InterfaceDefSeq *tmp = this->ptr_;
+  ::IR::ComponentDefSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_InterfaceDefSeq *
-CORBA_InterfaceDefSeq_var::ptr (void) const
+ACE_INLINE ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA::InterfaceDefSeq_out
+// Inline operations for class IR::ComponentDefSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (CORBA::InterfaceDefSeq *&p)
+IR::ComponentDefSeq_out::ComponentDefSeq_out (ComponentDefSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (CORBA::InterfaceDefSeq_var &p) // constructor from _var
+IR::ComponentDefSeq_out::ComponentDefSeq_out (ComponentDefSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -850,44 +1563,44 @@ CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (CORBA::InterfaceDefSeq_var
 }
 
 ACE_INLINE
-CORBA_InterfaceDefSeq_out::CORBA_InterfaceDefSeq_out (const CORBA_InterfaceDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA::InterfaceDefSeq_out&,p).ptr_)
+IR::ComponentDefSeq_out::ComponentDefSeq_out (const ::IR::ComponentDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ComponentDefSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_InterfaceDefSeq_out &
-CORBA_InterfaceDefSeq_out::operator= (const CORBA_InterfaceDefSeq_out &p)
+ACE_INLINE ::IR::ComponentDefSeq_out &
+IR::ComponentDefSeq_out::operator= (const ::IR::ComponentDefSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA::InterfaceDefSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ComponentDefSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_InterfaceDefSeq_out &
-CORBA_InterfaceDefSeq_out::operator= (CORBA_InterfaceDefSeq *p)
+ACE_INLINE ::IR::ComponentDefSeq_out &
+IR::ComponentDefSeq_out::operator= (ComponentDefSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_InterfaceDefSeq_out::operator CORBA_InterfaceDefSeq *&() // cast
+IR::ComponentDefSeq_out::operator ::IR::ComponentDefSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDefSeq *&
-CORBA_InterfaceDefSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::ComponentDefSeq *&
+IR::ComponentDefSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDefSeq *
-CORBA_InterfaceDefSeq_out::operator-> (void)
+ACE_INLINE ::IR::ComponentDefSeq *
+IR::ComponentDefSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE TAO_Object_Manager<CORBA::InterfaceDef,CORBA::InterfaceDef_var> 
-CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE TAO_Object_Manager<IR::ComponentDef, IR::ComponentDef_var> 
+IR::ComponentDefSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -898,26 +1611,24 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CI_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_VALUEDEFSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PROVIDESDEFSEQ_CI_
 
-  ACE_INLINE CORBA::ValueDef **
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (CORBA::ULong nelems)
+  ACE_INLINE IR::ProvidesDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (CORBA::ULong nelems)
   {
-    CORBA::ValueDef **buf = 0;
+    IR::ProvidesDef **buf = 0;
     
-    ACE_NEW_RETURN (buf, 
-                    CORBA::ValueDef*[nelems], 
-		    0);
+    ACE_NEW_RETURN (buf, IR::ProvidesDef*[nelems], 0);
     
     for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = CORBA::ValueDef::_nil ();
+      buf[i] = IR::ProvidesDef::_nil ();
     
     return buf;
   }
   
   ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (CORBA::ValueDef **buffer)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::freebuf (IR::ProvidesDef **buffer)
   {
     if (buffer == 0)
       return;
@@ -925,97 +1636,1854 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (void)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (void)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA::ValueDef* *value,
+    IR::ProvidesDef* *value,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs)
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA::ValueDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (this->maximum_);
-    CORBA::ValueDef ** const tmp2 = ACE_reinterpret_cast (CORBA::ValueDef ** ACE_CAST_CONST, rhs.buffer_);
+    if (rhs.buffer_ != 0)
+    {
+      IR::ProvidesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (this->maximum_);
+      IR::ProvidesDef ** const tmp2 = ACE_reinterpret_cast (IR::ProvidesDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::ProvidesDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::ProvidesDef **tmp = ACE_reinterpret_cast (IR::ProvidesDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::ProvidesDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::ProvidesDef **tmp1 = ACE_reinterpret_cast (IR::ProvidesDef **, this->buffer_);
+    IR::ProvidesDef ** const tmp2 = ACE_reinterpret_cast (IR::ProvidesDef ** ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = CORBA::ValueDef::_duplicate (tmp2[i]);
+      tmp1[i] = IR::ProvidesDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::ProvidesDef ** const tmp = ACE_reinterpret_cast (IR::ProvidesDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::ProvidesDef,IR::ProvidesDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::ProvidesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::ProvidesDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::ProvidesDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::ProvidesDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::ProvidesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ProvidesDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::ProvidesDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDEFSEQ_CI_)
+#define _IR_PROVIDESDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDefSeq_var::ProvidesDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ProvidesDefSeq_var::ProvidesDefSeq_var (ProvidesDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::ProvidesDefSeq_var::ProvidesDefSeq_var (const ::IR::ProvidesDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ProvidesDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDefSeq_var::~ProvidesDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDefSeq_var &
+IR::ProvidesDefSeq_var::operator= (ProvidesDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ProvidesDefSeq_var &
+IR::ProvidesDefSeq_var::operator= (const ::IR::ProvidesDefSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::ProvidesDefSeq (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDefSeq_var::operator const ::IR::ProvidesDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDefSeq_var::operator ::IR::ProvidesDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ProvidesDefSeq_var::operator ::IR::ProvidesDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ProvidesDefSeq_var::operator ::IR::ProvidesDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ProvidesDef, IR::ProvidesDef_var> 
+IR::ProvidesDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::ProvidesDefSeq &
+IR::ProvidesDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq &
+IR::ProvidesDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ProvidesDefSeq *&
+IR::ProvidesDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_var::_retn (void)
+{
+  ::IR::ProvidesDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ProvidesDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::ProvidesDefSeq_out::ProvidesDefSeq_out (ProvidesDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDefSeq_out::ProvidesDefSeq_out (ProvidesDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ProvidesDefSeq_out::ProvidesDefSeq_out (const ::IR::ProvidesDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ProvidesDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ProvidesDefSeq_out &
+IR::ProvidesDefSeq_out::operator= (const ::IR::ProvidesDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (ProvidesDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq_out &
+IR::ProvidesDefSeq_out::operator= (ProvidesDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ProvidesDefSeq_out::operator ::IR::ProvidesDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *&
+IR::ProvidesDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDefSeq *
+IR::ProvidesDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ProvidesDef, IR::ProvidesDef_var> 
+IR::ProvidesDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_USESDEFSEQ_CI_
+
+  ACE_INLINE IR::UsesDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::UsesDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::UsesDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::UsesDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::freebuf (IR::UsesDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::UsesDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::UsesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (this->maximum_);
+      IR::UsesDef ** const tmp2 = ACE_reinterpret_cast (IR::UsesDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::UsesDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::UsesDef **tmp = ACE_reinterpret_cast (IR::UsesDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::UsesDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::UsesDef **tmp1 = ACE_reinterpret_cast (IR::UsesDef **, this->buffer_);
+    IR::UsesDef ** const tmp2 = ACE_reinterpret_cast (IR::UsesDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::UsesDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::UsesDef ** const tmp = ACE_reinterpret_cast (IR::UsesDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::UsesDef,IR::UsesDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::UsesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::UsesDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::UsesDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::UsesDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::UsesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_UsesDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::UsesDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_USESDEFSEQ_CI_)
+#define _IR_USESDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::UsesDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDefSeq_var::UsesDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::UsesDefSeq_var::UsesDefSeq_var (UsesDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::UsesDefSeq_var::UsesDefSeq_var (const ::IR::UsesDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::UsesDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDefSeq_var::~UsesDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::UsesDefSeq_var &
+IR::UsesDefSeq_var::operator= (UsesDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::UsesDefSeq_var &
+IR::UsesDefSeq_var::operator= (const ::IR::UsesDefSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::UsesDefSeq (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::UsesDefSeq *
+IR::UsesDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *
+IR::UsesDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDefSeq_var::operator const ::IR::UsesDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDefSeq_var::operator ::IR::UsesDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDefSeq_var::operator ::IR::UsesDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::UsesDefSeq_var::operator ::IR::UsesDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::UsesDef, IR::UsesDef_var> 
+IR::UsesDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::UsesDefSeq &
+IR::UsesDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq &
+IR::UsesDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::UsesDefSeq *&
+IR::UsesDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *
+IR::UsesDefSeq_var::_retn (void)
+{
+  ::IR::UsesDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *
+IR::UsesDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::UsesDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDefSeq_out::UsesDefSeq_out (UsesDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDefSeq_out::UsesDefSeq_out (UsesDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::UsesDefSeq_out::UsesDefSeq_out (const ::IR::UsesDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UsesDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::UsesDefSeq_out &
+IR::UsesDefSeq_out::operator= (const ::IR::UsesDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (UsesDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::UsesDefSeq_out &
+IR::UsesDefSeq_out::operator= (UsesDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::UsesDefSeq_out::operator ::IR::UsesDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *&
+IR::UsesDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDefSeq *
+IR::UsesDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::UsesDef, IR::UsesDef_var> 
+IR::UsesDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_HOMEDEFSEQ_CI_
+
+  ACE_INLINE IR::HomeDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::HomeDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::HomeDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::HomeDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::freebuf (IR::HomeDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::HomeDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq(const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::HomeDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (this->maximum_);
+      IR::HomeDef ** const tmp2 = ACE_reinterpret_cast (IR::HomeDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::HomeDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::HomeDef **tmp = ACE_reinterpret_cast (IR::HomeDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::HomeDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::HomeDef **tmp1 = ACE_reinterpret_cast (IR::HomeDef **, this->buffer_);
+    IR::HomeDef ** const tmp2 = ACE_reinterpret_cast (IR::HomeDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::HomeDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::HomeDef ** const tmp = ACE_reinterpret_cast (IR::HomeDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::HomeDef,IR::HomeDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::HomeDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::HomeDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::HomeDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::HomeDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::HomeDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_HomeDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::HomeDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_HOMEDEFSEQ_CI_)
+#define _IR_HOMEDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::HomeDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDefSeq_var::HomeDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::HomeDefSeq_var::HomeDefSeq_var (HomeDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::HomeDefSeq_var::HomeDefSeq_var (const ::IR::HomeDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::HomeDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDefSeq_var::~HomeDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::HomeDefSeq_var &
+IR::HomeDefSeq_var::operator= (HomeDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::HomeDefSeq_var &
+IR::HomeDefSeq_var::operator= (const ::IR::HomeDefSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::HomeDefSeq (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::HomeDefSeq *
+IR::HomeDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *
+IR::HomeDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::HomeDefSeq_var::operator const ::IR::HomeDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::HomeDefSeq_var::operator ::IR::HomeDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::HomeDefSeq_var::operator ::IR::HomeDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::HomeDefSeq_var::operator ::IR::HomeDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::HomeDef, IR::HomeDef_var> 
+IR::HomeDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::HomeDefSeq &
+IR::HomeDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq &
+IR::HomeDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::HomeDefSeq *&
+IR::HomeDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *
+IR::HomeDefSeq_var::_retn (void)
+{
+  ::IR::HomeDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *
+IR::HomeDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::HomeDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDefSeq_out::HomeDefSeq_out (HomeDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDefSeq_out::HomeDefSeq_out (HomeDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDefSeq_out::HomeDefSeq_out (const ::IR::HomeDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (HomeDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::HomeDefSeq_out &
+IR::HomeDefSeq_out::operator= (const ::IR::HomeDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (HomeDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::HomeDefSeq_out &
+IR::HomeDefSeq_out::operator= (HomeDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::HomeDefSeq_out::operator ::IR::HomeDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *&
+IR::HomeDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDefSeq *
+IR::HomeDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::HomeDef, IR::HomeDef_var> 
+IR::HomeDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EMITSDEFSEQ_CI_
+
+  ACE_INLINE IR::EmitsDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::EmitsDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::EmitsDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::EmitsDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::freebuf (IR::EmitsDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::EmitsDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq(const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::EmitsDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (this->maximum_);
+      IR::EmitsDef ** const tmp2 = ACE_reinterpret_cast (IR::EmitsDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::EmitsDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::EmitsDef **tmp = ACE_reinterpret_cast (IR::EmitsDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::EmitsDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::EmitsDef **tmp1 = ACE_reinterpret_cast (IR::EmitsDef **, this->buffer_);
+    IR::EmitsDef ** const tmp2 = ACE_reinterpret_cast (IR::EmitsDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::EmitsDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::EmitsDef ** const tmp = ACE_reinterpret_cast (IR::EmitsDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::EmitsDef,IR::EmitsDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::EmitsDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::EmitsDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::EmitsDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::EmitsDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::EmitsDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_EmitsDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::EmitsDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EMITSDEFSEQ_CI_)
+#define _IR_EMITSDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::EmitsDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::EmitsDefSeq_var::EmitsDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::EmitsDefSeq_var::EmitsDefSeq_var (EmitsDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::EmitsDefSeq_var::EmitsDefSeq_var (const ::IR::EmitsDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::EmitsDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EmitsDefSeq_var::~EmitsDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::EmitsDefSeq_var &
+IR::EmitsDefSeq_var::operator= (EmitsDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::EmitsDefSeq_var &
+IR::EmitsDefSeq_var::operator= (const ::IR::EmitsDefSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::EmitsDefSeq (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::EmitsDefSeq_var::operator const ::IR::EmitsDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::EmitsDefSeq_var::operator ::IR::EmitsDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::EmitsDefSeq_var::operator ::IR::EmitsDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::EmitsDefSeq_var::operator ::IR::EmitsDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::EmitsDef, IR::EmitsDef_var> 
+IR::EmitsDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::EmitsDefSeq &
+IR::EmitsDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq &
+IR::EmitsDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::EmitsDefSeq *&
+IR::EmitsDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_var::_retn (void)
+{
+  ::IR::EmitsDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::EmitsDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::EmitsDefSeq_out::EmitsDefSeq_out (EmitsDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EmitsDefSeq_out::EmitsDefSeq_out (EmitsDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EmitsDefSeq_out::EmitsDefSeq_out (const ::IR::EmitsDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (EmitsDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::EmitsDefSeq_out &
+IR::EmitsDefSeq_out::operator= (const ::IR::EmitsDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (EmitsDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq_out &
+IR::EmitsDefSeq_out::operator= (EmitsDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::EmitsDefSeq_out::operator ::IR::EmitsDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *&
+IR::EmitsDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EmitsDefSeq *
+IR::EmitsDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::EmitsDef, IR::EmitsDef_var> 
+IR::EmitsDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_PUBLISHESDEFSEQ_CI_
+
+  ACE_INLINE IR::PublishesDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::PublishesDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::PublishesDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::PublishesDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::freebuf (IR::PublishesDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::PublishesDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::PublishesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (this->maximum_);
+      IR::PublishesDef ** const tmp2 = ACE_reinterpret_cast (IR::PublishesDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::PublishesDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::PublishesDef **tmp = ACE_reinterpret_cast (IR::PublishesDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::PublishesDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::PublishesDef **tmp1 = ACE_reinterpret_cast (IR::PublishesDef **, this->buffer_);
+    IR::PublishesDef ** const tmp2 = ACE_reinterpret_cast (IR::PublishesDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::PublishesDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::PublishesDef ** const tmp = ACE_reinterpret_cast (IR::PublishesDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::PublishesDef,IR::PublishesDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::PublishesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::PublishesDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::PublishesDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::PublishesDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::PublishesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_PublishesDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::PublishesDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PUBLISHESDEFSEQ_CI_)
+#define _IR_PUBLISHESDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::PublishesDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::PublishesDefSeq_var::PublishesDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::PublishesDefSeq_var::PublishesDefSeq_var (PublishesDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::PublishesDefSeq_var::PublishesDefSeq_var (const ::IR::PublishesDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::PublishesDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PublishesDefSeq_var::~PublishesDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::PublishesDefSeq_var &
+IR::PublishesDefSeq_var::operator= (PublishesDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::PublishesDefSeq_var &
+IR::PublishesDefSeq_var::operator= (const ::IR::PublishesDefSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::PublishesDefSeq (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::PublishesDefSeq_var::operator const ::IR::PublishesDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::PublishesDefSeq_var::operator ::IR::PublishesDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::PublishesDefSeq_var::operator ::IR::PublishesDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::PublishesDefSeq_var::operator ::IR::PublishesDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::PublishesDef, IR::PublishesDef_var> 
+IR::PublishesDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::PublishesDefSeq &
+IR::PublishesDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq &
+IR::PublishesDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::PublishesDefSeq *&
+IR::PublishesDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_var::_retn (void)
+{
+  ::IR::PublishesDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::PublishesDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::PublishesDefSeq_out::PublishesDefSeq_out (PublishesDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PublishesDefSeq_out::PublishesDefSeq_out (PublishesDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PublishesDefSeq_out::PublishesDefSeq_out (const ::IR::PublishesDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (PublishesDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::PublishesDefSeq_out &
+IR::PublishesDefSeq_out::operator= (const ::IR::PublishesDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (PublishesDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq_out &
+IR::PublishesDefSeq_out::operator= (PublishesDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::PublishesDefSeq_out::operator ::IR::PublishesDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *&
+IR::PublishesDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PublishesDefSeq *
+IR::PublishesDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::PublishesDef, IR::PublishesDef_var> 
+IR::PublishesDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONSUMESDEFSEQ_CI_
+
+  ACE_INLINE IR::ConsumesDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::ConsumesDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::ConsumesDef*[nelems], 0);
     
-    this->buffer_ = tmp1;
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::ConsumesDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::freebuf (IR::ConsumesDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::ConsumesDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
   }
   
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq &rhs)
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::ConsumesDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (this->maximum_);
+      IR::ConsumesDef ** const tmp2 = ACE_reinterpret_cast (IR::ConsumesDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::ConsumesDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq &rhs)
   {
     if (this == &rhs)
       return *this;
     
     if (this->release_)
     {
-      CORBA::ValueDef **tmp = ACE_reinterpret_cast (CORBA::ValueDef **, this->buffer_);
+      IR::ConsumesDef **tmp = ACE_reinterpret_cast (IR::ConsumesDef **, this->buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
       {
         CORBA::release (tmp[i]);
-        tmp[i] = CORBA::ValueDef::_nil ();
+        tmp[i] = IR::ConsumesDef::_nil ();
       }
       if (this->maximum_ < rhs.maximum_)
       {
-        _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (rhs.maximum_);
+        _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA::ValueDef **tmp1 = ACE_reinterpret_cast (CORBA::ValueDef **, this->buffer_);
-    CORBA::ValueDef ** const tmp2 = ACE_reinterpret_cast (CORBA::ValueDef ** ACE_CAST_CONST, rhs.buffer_);
+    IR::ConsumesDef **tmp1 = ACE_reinterpret_cast (IR::ConsumesDef **, this->buffer_);
+    IR::ConsumesDef ** const tmp2 = ACE_reinterpret_cast (IR::ConsumesDef ** ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = CORBA::ValueDef::_duplicate (tmp2[i]);
+      tmp1[i] = IR::ConsumesDef::_duplicate (tmp2[i]);
     
     return *this;
   }
   
-  ACE_INLINE TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var>
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::operator[] (CORBA::ULong index) const
+  ACE_INLINE TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::operator[] (CORBA::ULong index) const
   // read-write accessor
   {
     ACE_ASSERT (index < this->maximum_);
-    CORBA::ValueDef ** const tmp = ACE_reinterpret_cast (CORBA::ValueDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var> (tmp + index, this->release_);
+    IR::ConsumesDef ** const tmp = ACE_reinterpret_cast (IR::ConsumesDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::ConsumesDef,IR::ConsumesDef_var> (tmp + index, this->release_);
   }
   
-  ACE_INLINE CORBA::ValueDef* *
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::ConsumesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA::ValueDef **result = 0;
+    IR::ConsumesDef **result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::allocbuf (this->maximum_);
+        result = _TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::allocbuf (this->maximum_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA::ValueDef**, this->buffer_);
+        result = ACE_reinterpret_cast (IR::ConsumesDef**, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -1024,7 +3492,7 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA::ValueDef**,this->buffer_);
+        result = ACE_reinterpret_cast(IR::ConsumesDef**,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -1034,10 +3502,10 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
     return result;
   }
   
-  ACE_INLINE const CORBA::ValueDef* *
-  _TAO_Unbounded_Object_Sequence_CORBA_ValueDefSeq::get_buffer (void) const
+  ACE_INLINE const IR::ConsumesDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ConsumesDefSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA::ValueDef ** ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::ConsumesDef ** ACE_CAST_CONST, this->buffer_);
   }
   
   
@@ -1046,144 +3514,148 @@ CORBA_InterfaceDefSeq_out::operator[] (CORBA::ULong index)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_VALUEDEFSEQ_CI_)
-#define _CORBA_VALUEDEFSEQ_CI_
+#if !defined (_IR_CONSUMESDEFSEQ_CI_)
+#define _IR_CONSUMESDEFSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA::ValueDefSeq_var
+// Inline operations for class IR::ConsumesDefSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueDefSeq_var::CORBA_ValueDefSeq_var (void) // default constructor
+IR::ConsumesDefSeq_var::ConsumesDefSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ValueDefSeq_var::CORBA_ValueDefSeq_var (CORBA::ValueDefSeq *p)
+IR::ConsumesDefSeq_var::ConsumesDefSeq_var (ConsumesDefSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ValueDefSeq_var::CORBA_ValueDefSeq_var (const CORBA::ValueDefSeq_var &p) // copy constructor
+IR::ConsumesDefSeq_var::ConsumesDefSeq_var (const ::IR::ConsumesDefSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA::ValueDefSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ConsumesDefSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueDefSeq_var::~CORBA_ValueDefSeq_var (void) // destructor
+IR::ConsumesDefSeq_var::~ConsumesDefSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDefSeq_var &
-CORBA_ValueDefSeq_var::operator= (CORBA::ValueDefSeq *p)
+ACE_INLINE IR::ConsumesDefSeq_var &
+IR::ConsumesDefSeq_var::operator= (ConsumesDefSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueDefSeq_var &
-CORBA_ValueDefSeq_var::operator= (const CORBA::ValueDefSeq_var &p) // deep copy
+ACE_INLINE IR::ConsumesDefSeq_var &
+IR::ConsumesDefSeq_var::operator= (const ::IR::ConsumesDefSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA::ValueDefSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ConsumesDefSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ValueDefSeq *
-CORBA_ValueDefSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDefSeq *
-CORBA_ValueDefSeq_var::operator-> (void)
+ACE_INLINE ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueDefSeq_var::operator const CORBA::ValueDefSeq &() const // cast
+IR::ConsumesDefSeq_var::operator const ::IR::ConsumesDefSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueDefSeq_var::operator CORBA::ValueDefSeq &() // cast 
+IR::ConsumesDefSeq_var::operator ::IR::ConsumesDefSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueDefSeq_var::operator CORBA::ValueDefSeq &() const// cast 
+IR::ConsumesDefSeq_var::operator ::IR::ConsumesDefSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE TAO_Object_Manager<CORBA::ValueDef,CORBA::ValueDef_var> 
-CORBA_ValueDefSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::ConsumesDefSeq_var::operator ::IR::ConsumesDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ConsumesDef, IR::ConsumesDef_var> 
+IR::ConsumesDefSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_ValueDefSeq &
-CORBA_ValueDefSeq_var::in (void) const
+ACE_INLINE const ::IR::ConsumesDefSeq &
+IR::ConsumesDefSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDefSeq &
-CORBA_ValueDefSeq_var::inout (void)
+ACE_INLINE ::IR::ConsumesDefSeq &
+IR::ConsumesDefSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ValueDefSeq *&
-CORBA_ValueDefSeq_var::out (void)
+ACE_INLINE ::IR::ConsumesDefSeq *&
+IR::ConsumesDefSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDefSeq *
-CORBA_ValueDefSeq_var::_retn (void)
+ACE_INLINE ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_var::_retn (void)
 {
-  CORBA::ValueDefSeq *tmp = this->ptr_;
+  ::IR::ConsumesDefSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ValueDefSeq *
-CORBA_ValueDefSeq_var::ptr (void) const
+ACE_INLINE ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA::ValueDefSeq_out
+// Inline operations for class IR::ConsumesDefSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (CORBA::ValueDefSeq *&p)
+IR::ConsumesDefSeq_out::ConsumesDefSeq_out (ConsumesDefSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (CORBA::ValueDefSeq_var &p) // constructor from _var
+IR::ConsumesDefSeq_out::ConsumesDefSeq_out (ConsumesDefSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -1191,44 +3663,44 @@ CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (CORBA::ValueDefSeq_var &p) // cons
 }
 
 ACE_INLINE
-CORBA_ValueDefSeq_out::CORBA_ValueDefSeq_out (const CORBA::ValueDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ValueDefSeq_out&,p).ptr_)
+IR::ConsumesDefSeq_out::ConsumesDefSeq_out (const ::IR::ConsumesDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ConsumesDefSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ValueDefSeq_out &
-CORBA_ValueDefSeq_out::operator= (const CORBA_ValueDefSeq_out &p)
+ACE_INLINE ::IR::ConsumesDefSeq_out &
+IR::ConsumesDefSeq_out::operator= (const ::IR::ConsumesDefSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ValueDefSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ConsumesDefSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueDefSeq_out &
-CORBA_ValueDefSeq_out::operator= (CORBA_ValueDefSeq *p)
+ACE_INLINE ::IR::ConsumesDefSeq_out &
+IR::ConsumesDefSeq_out::operator= (ConsumesDefSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueDefSeq_out::operator CORBA_ValueDefSeq *&() // cast
+IR::ConsumesDefSeq_out::operator ::IR::ConsumesDefSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDefSeq *&
-CORBA_ValueDefSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::ConsumesDefSeq *&
+IR::ConsumesDefSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDefSeq *
-CORBA_ValueDefSeq_out::operator-> (void)
+ACE_INLINE ::IR::ConsumesDefSeq *
+IR::ConsumesDefSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE TAO_Object_Manager<CORBA_ValueDef,CORBA_ValueDef_var> 
-CORBA_ValueDefSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE TAO_Object_Manager<IR::ConsumesDef, IR::ConsumesDef_var> 
+IR::ConsumesDefSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -1239,26 +3711,24 @@ CORBA_ValueDefSeq_out::operator[] (CORBA::ULong index)
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_CONTAINEDSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FACTORYDEFSEQ_CI_
 
-  ACE_INLINE CORBA_Contained **
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (CORBA::ULong nelems)
+  ACE_INLINE IR::FactoryDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (CORBA::ULong nelems)
   {
-    CORBA::Contained **buf = 0;
+    IR::FactoryDef **buf = 0;
     
-    ACE_NEW_RETURN (buf, 
-                    CORBA::Contained*[nelems], 
-		    0);
+    ACE_NEW_RETURN (buf, IR::FactoryDef*[nelems], 0);
     
     for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = CORBA::Contained::_nil ();
+      buf[i] = IR::FactoryDef::_nil ();
     
     return buf;
   }
   
   ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (CORBA::Contained **buffer)
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::freebuf (IR::FactoryDef **buffer)
   {
     if (buffer == 0)
       return;
@@ -1266,97 +3736,454 @@ CORBA_ValueDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (void)
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (void)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA::Contained* *value,
+    IR::FactoryDef* *value,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::_TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs)
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA::Contained **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_);
-    CORBA::Contained ** const tmp2 = ACE_reinterpret_cast (CORBA::Contained ** ACE_CAST_CONST, rhs.buffer_);
+    if (rhs.buffer_ != 0)
+    {
+      IR::FactoryDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (this->maximum_);
+      IR::FactoryDef ** const tmp2 = ACE_reinterpret_cast (IR::FactoryDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::FactoryDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::FactoryDef **tmp = ACE_reinterpret_cast (IR::FactoryDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::FactoryDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::FactoryDef **tmp1 = ACE_reinterpret_cast (IR::FactoryDef **, this->buffer_);
+    IR::FactoryDef ** const tmp2 = ACE_reinterpret_cast (IR::FactoryDef ** ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = CORBA::Contained::_duplicate (tmp2[i]);
+      tmp1[i] = IR::FactoryDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::FactoryDef ** const tmp = ACE_reinterpret_cast (IR::FactoryDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::FactoryDef,IR::FactoryDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::FactoryDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::FactoryDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::FactoryDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::FactoryDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::FactoryDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_FactoryDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::FactoryDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_FACTORYDEFSEQ_CI_)
+#define _IR_FACTORYDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::FactoryDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::FactoryDefSeq_var::FactoryDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::FactoryDefSeq_var::FactoryDefSeq_var (FactoryDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::FactoryDefSeq_var::FactoryDefSeq_var (const ::IR::FactoryDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::FactoryDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::FactoryDefSeq_var::~FactoryDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::FactoryDefSeq_var &
+IR::FactoryDefSeq_var::operator= (FactoryDefSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::FactoryDefSeq_var &
+IR::FactoryDefSeq_var::operator= (const ::IR::FactoryDefSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::FactoryDefSeq (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::FactoryDefSeq_var::operator const ::IR::FactoryDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::FactoryDefSeq_var::operator ::IR::FactoryDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::FactoryDefSeq_var::operator ::IR::FactoryDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::FactoryDefSeq_var::operator ::IR::FactoryDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::FactoryDef, IR::FactoryDef_var> 
+IR::FactoryDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::FactoryDefSeq &
+IR::FactoryDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq &
+IR::FactoryDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::FactoryDefSeq *&
+IR::FactoryDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_var::_retn (void)
+{
+  ::IR::FactoryDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::FactoryDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::FactoryDefSeq_out::FactoryDefSeq_out (FactoryDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::FactoryDefSeq_out::FactoryDefSeq_out (FactoryDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::FactoryDefSeq_out::FactoryDefSeq_out (const ::IR::FactoryDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (FactoryDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::FactoryDefSeq_out &
+IR::FactoryDefSeq_out::operator= (const ::IR::FactoryDefSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (FactoryDefSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq_out &
+IR::FactoryDefSeq_out::operator= (FactoryDefSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::FactoryDefSeq_out::operator ::IR::FactoryDefSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *&
+IR::FactoryDefSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDefSeq *
+IR::FactoryDefSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::FactoryDef, IR::FactoryDef_var> 
+IR::FactoryDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_FINDERDEFSEQ_CI_
+
+  ACE_INLINE IR::FinderDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::FinderDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::FinderDef*[nelems], 0);
     
-    this->buffer_ = tmp1;
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::FinderDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::freebuf (IR::FinderDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::FinderDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq(const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::FinderDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (this->maximum_);
+      IR::FinderDef ** const tmp2 = ACE_reinterpret_cast (IR::FinderDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::FinderDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq &rhs)
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq &rhs)
   {
     if (this == &rhs)
       return *this;
     
     if (this->release_)
     {
-      CORBA::Contained **tmp = ACE_reinterpret_cast (CORBA::Contained **, this->buffer_);
+      IR::FinderDef **tmp = ACE_reinterpret_cast (IR::FinderDef **, this->buffer_);
       
       for (CORBA::ULong i = 0; i < this->length_; ++i)
       {
         CORBA::release (tmp[i]);
-        tmp[i] = CORBA::Contained::_nil ();
+        tmp[i] = IR::FinderDef::_nil ();
       }
       if (this->maximum_ < rhs.maximum_)
       {
-        _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (rhs.maximum_);
+        _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA::Contained **tmp1 = ACE_reinterpret_cast (CORBA::Contained **, this->buffer_);
-    CORBA::Contained ** const tmp2 = ACE_reinterpret_cast (CORBA::Contained ** ACE_CAST_CONST, rhs.buffer_);
+    IR::FinderDef **tmp1 = ACE_reinterpret_cast (IR::FinderDef **, this->buffer_);
+    IR::FinderDef ** const tmp2 = ACE_reinterpret_cast (IR::FinderDef ** ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = CORBA::Contained::_duplicate (tmp2[i]);
+      tmp1[i] = IR::FinderDef::_duplicate (tmp2[i]);
     
     return *this;
   }
   
-  ACE_INLINE TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var>
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::operator[] (CORBA::ULong index) const
+  ACE_INLINE TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::operator[] (CORBA::ULong index) const
   // read-write accessor
   {
     ACE_ASSERT (index < this->maximum_);
-    CORBA::Contained ** const tmp = ACE_reinterpret_cast (CORBA::Contained ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> (tmp + index, this->release_);
+    IR::FinderDef ** const tmp = ACE_reinterpret_cast (IR::FinderDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::FinderDef,IR::FinderDef_var> (tmp + index, this->release_);
   }
   
-  ACE_INLINE CORBA::Contained* *
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::FinderDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA::Contained **result = 0;
+    IR::FinderDef **result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::allocbuf (this->maximum_);
+        result = _TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::allocbuf (this->maximum_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA::Contained**, this->buffer_);
+        result = ACE_reinterpret_cast (IR::FinderDef**, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -1365,7 +4192,7 @@ CORBA_ValueDefSeq_out::operator[] (CORBA::ULong index)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA::Contained**,this->buffer_);
+        result = ACE_reinterpret_cast(IR::FinderDef**,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -1375,10 +4202,10 @@ CORBA_ValueDefSeq_out::operator[] (CORBA::ULong index)
     return result;
   }
   
-  ACE_INLINE const CORBA::Contained* *
-  _TAO_Unbounded_Object_Sequence_CORBA_ContainedSeq::get_buffer (void) const
+  ACE_INLINE const IR::FinderDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_FinderDefSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA::Contained ** ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::FinderDef ** ACE_CAST_CONST, this->buffer_);
   }
   
   
@@ -1387,144 +4214,148 @@ CORBA_ValueDefSeq_out::operator[] (CORBA::ULong index)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_CONTAINEDSEQ_CI_)
-#define _CORBA_CONTAINEDSEQ_CI_
+#if !defined (_IR_FINDERDEFSEQ_CI_)
+#define _IR_FINDERDEFSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA::ContainedSeq_var
+// Inline operations for class IR::FinderDefSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ContainedSeq_var::CORBA_ContainedSeq_var (void) // default constructor
+IR::FinderDefSeq_var::FinderDefSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ContainedSeq_var::CORBA_ContainedSeq_var (CORBA::ContainedSeq *p)
+IR::FinderDefSeq_var::FinderDefSeq_var (FinderDefSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ContainedSeq_var::CORBA_ContainedSeq_var (const CORBA_ContainedSeq_var &p) // copy constructor
+IR::FinderDefSeq_var::FinderDefSeq_var (const ::IR::FinderDefSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ContainedSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::FinderDefSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ContainedSeq_var::~CORBA_ContainedSeq_var (void) // destructor
+IR::FinderDefSeq_var::~FinderDefSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ContainedSeq_var &
-CORBA_ContainedSeq_var::operator= (CORBA_ContainedSeq *p)
+ACE_INLINE IR::FinderDefSeq_var &
+IR::FinderDefSeq_var::operator= (FinderDefSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ContainedSeq_var &
-CORBA_ContainedSeq_var::operator= (const CORBA_ContainedSeq_var &p) // deep copy
+ACE_INLINE IR::FinderDefSeq_var &
+IR::FinderDefSeq_var::operator= (const ::IR::FinderDefSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ContainedSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::FinderDefSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ContainedSeq *
-CORBA_ContainedSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::FinderDefSeq *
+IR::FinderDefSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ContainedSeq *
-CORBA_ContainedSeq_var::operator-> (void)
+ACE_INLINE ::IR::FinderDefSeq *
+IR::FinderDefSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ContainedSeq_var::operator const CORBA_ContainedSeq &() const // cast
+IR::FinderDefSeq_var::operator const ::IR::FinderDefSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ContainedSeq_var::operator CORBA_ContainedSeq &() // cast 
+IR::FinderDefSeq_var::operator ::IR::FinderDefSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ContainedSeq_var::operator CORBA_ContainedSeq &() const// cast 
+IR::FinderDefSeq_var::operator ::IR::FinderDefSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> 
-CORBA_ContainedSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::FinderDefSeq_var::operator ::IR::FinderDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::FinderDef, IR::FinderDef_var> 
+IR::FinderDefSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_ContainedSeq &
-CORBA_ContainedSeq_var::in (void) const
+ACE_INLINE const ::IR::FinderDefSeq &
+IR::FinderDefSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ContainedSeq &
-CORBA_ContainedSeq_var::inout (void)
+ACE_INLINE ::IR::FinderDefSeq &
+IR::FinderDefSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ContainedSeq *&
-CORBA_ContainedSeq_var::out (void)
+ACE_INLINE ::IR::FinderDefSeq *&
+IR::FinderDefSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ContainedSeq *
-CORBA_ContainedSeq_var::_retn (void)
+ACE_INLINE ::IR::FinderDefSeq *
+IR::FinderDefSeq_var::_retn (void)
 {
-  CORBA_ContainedSeq *tmp = this->ptr_;
+  ::IR::FinderDefSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ContainedSeq *
-CORBA_ContainedSeq_var::ptr (void) const
+ACE_INLINE ::IR::FinderDefSeq *
+IR::FinderDefSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA::ContainedSeq_out
+// Inline operations for class IR::FinderDefSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ContainedSeq_out::CORBA_ContainedSeq_out (CORBA_ContainedSeq *&p)
+IR::FinderDefSeq_out::FinderDefSeq_out (FinderDefSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ContainedSeq_out::CORBA_ContainedSeq_out (CORBA_ContainedSeq_var &p) // constructor from _var
+IR::FinderDefSeq_out::FinderDefSeq_out (FinderDefSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -1532,44 +4363,44 @@ CORBA_ContainedSeq_out::CORBA_ContainedSeq_out (CORBA_ContainedSeq_var &p) // co
 }
 
 ACE_INLINE
-CORBA_ContainedSeq_out::CORBA_ContainedSeq_out (const CORBA_ContainedSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA::ContainedSeq_out&,p).ptr_)
+IR::FinderDefSeq_out::FinderDefSeq_out (const ::IR::FinderDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (FinderDefSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ContainedSeq_out &
-CORBA_ContainedSeq_out::operator= (const CORBA_ContainedSeq_out &p)
+ACE_INLINE ::IR::FinderDefSeq_out &
+IR::FinderDefSeq_out::operator= (const ::IR::FinderDefSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ContainedSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (FinderDefSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ContainedSeq_out &
-CORBA_ContainedSeq_out::operator= (CORBA_ContainedSeq *p)
+ACE_INLINE ::IR::FinderDefSeq_out &
+IR::FinderDefSeq_out::operator= (FinderDefSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ContainedSeq_out::operator CORBA_ContainedSeq *&() // cast
+IR::FinderDefSeq_out::operator ::IR::FinderDefSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ContainedSeq *&
-CORBA_ContainedSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::FinderDefSeq *&
+IR::FinderDefSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ContainedSeq *
-CORBA_ContainedSeq_out::operator-> (void)
+ACE_INLINE ::IR::FinderDefSeq *
+IR::FinderDefSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE TAO_Object_Manager<CORBA::Contained,CORBA::Contained_var> 
-CORBA_ContainedSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE TAO_Object_Manager<IR::FinderDef, IR::FinderDef_var> 
+IR::FinderDefSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -1577,135 +4408,489 @@ CORBA_ContainedSeq_out::operator[] (CORBA::ULong index)
 
 #endif /* end #if !defined */
 
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONTAINEDSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_CONTAINEDSEQ_CI_
+
+  ACE_INLINE IR::Contained **
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::Contained **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::Contained*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::Contained::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::freebuf (IR::Contained **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::Contained* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq(const _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::Contained **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (this->maximum_);
+      IR::Contained ** const tmp2 = ACE_reinterpret_cast (IR::Contained ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::Contained::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ContainedSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::Contained **tmp = ACE_reinterpret_cast (IR::Contained **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::Contained::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::Contained **tmp1 = ACE_reinterpret_cast (IR::Contained **, this->buffer_);
+    IR::Contained ** const tmp2 = ACE_reinterpret_cast (IR::Contained ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::Contained::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::Contained,IR::Contained_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::Contained ** const tmp = ACE_reinterpret_cast (IR::Contained ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::Contained,IR::Contained_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::Contained* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::Contained **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_ContainedSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::Contained**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::Contained**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::Contained* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ContainedSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::Contained ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_CONTAINEDSEQ_CI_)
+#define _IR_CONTAINEDSEQ_CI_
+
 // *************************************************************
-// Inline operations for class CORBA::StructMember_var
+// Inline operations for class IR::ContainedSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_StructMember_var::CORBA_StructMember_var (void) // default constructor
+IR::ContainedSeq_var::ContainedSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_StructMember_var::CORBA_StructMember_var (CORBA_StructMember *p)
+IR::ContainedSeq_var::ContainedSeq_var (ContainedSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_StructMember_var::CORBA_StructMember_var (const CORBA_StructMember_var &p) // copy constructor
+IR::ContainedSeq_var::ContainedSeq_var (const ::IR::ContainedSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA::StructMember(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ContainedSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_StructMember_var::~CORBA_StructMember_var (void) // destructor
+IR::ContainedSeq_var::~ContainedSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMember_var &
-CORBA_StructMember_var::operator= (CORBA::StructMember *p)
+ACE_INLINE IR::ContainedSeq_var &
+IR::ContainedSeq_var::operator= (ContainedSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_StructMember_var &
-CORBA_StructMember_var::operator= (const CORBA_StructMember_var &p)
+ACE_INLINE IR::ContainedSeq_var &
+IR::ContainedSeq_var::operator= (const ::IR::ContainedSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA::StructMember (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ContainedSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_StructMember *
-CORBA_StructMember_var::operator-> (void) const
+ACE_INLINE const ::IR::ContainedSeq *
+IR::ContainedSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMember *
-CORBA_StructMember_var::operator-> (void)
+ACE_INLINE ::IR::ContainedSeq *
+IR::ContainedSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StructMember_var::operator const CORBA::StructMember &() const // cast
+IR::ContainedSeq_var::operator const ::IR::ContainedSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StructMember_var::operator CORBA_StructMember &() // cast 
+IR::ContainedSeq_var::operator ::IR::ContainedSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ContainedSeq_var::operator ::IR::ContainedSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ContainedSeq_var::operator ::IR::ContainedSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::Contained, IR::Contained_var> 
+IR::ContainedSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::ContainedSeq &
+IR::ContainedSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
+ACE_INLINE ::IR::ContainedSeq &
+IR::ContainedSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ContainedSeq *&
+IR::ContainedSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ContainedSeq *
+IR::ContainedSeq_var::_retn (void)
+{
+  ::IR::ContainedSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ContainedSeq *
+IR::ContainedSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ContainedSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::ContainedSeq_out::ContainedSeq_out (ContainedSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ContainedSeq_out::ContainedSeq_out (ContainedSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ContainedSeq_out::ContainedSeq_out (const ::IR::ContainedSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ContainedSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ContainedSeq_out &
+IR::ContainedSeq_out::operator= (const ::IR::ContainedSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (ContainedSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::ContainedSeq_out &
+IR::ContainedSeq_out::operator= (ContainedSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
 ACE_INLINE 
-CORBA_StructMember_var::operator CORBA_StructMember &() const// cast 
+IR::ContainedSeq_out::operator ::IR::ContainedSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ContainedSeq *&
+IR::ContainedSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ContainedSeq *
+IR::ContainedSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::Contained, IR::Contained_var> 
+IR::ContainedSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class IR::StructMember_var
+// *************************************************************
+
+ACE_INLINE
+IR::StructMember_var::StructMember_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::StructMember_var::StructMember_var (StructMember *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::StructMember_var::StructMember_var (const ::IR::StructMember_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::StructMember (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::StructMember_var::~StructMember_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::StructMember_var &
+IR::StructMember_var::operator= (StructMember *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::StructMember_var &
+IR::StructMember_var::operator= (const ::IR::StructMember_var &p)
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::StructMember (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::StructMember *
+IR::StructMember_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::StructMember *
+IR::StructMember_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::StructMember_var::operator const ::IR::StructMember &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::StructMember_var::operator ::IR::StructMember &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_StructMember &
-CORBA_StructMember_var::in (void) const
+ACE_INLINE
+IR::StructMember_var::operator ::IR::StructMember &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::StructMember_var::operator ::IR::StructMember *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::StructMember &
+IR::StructMember_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMember &
-CORBA_StructMember_var::inout (void)
+ACE_INLINE ::IR::StructMember &
+IR::StructMember_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_StructMember *&
-CORBA_StructMember_var::out (void)
+ACE_INLINE ::IR::StructMember *&
+IR::StructMember_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMember *
-CORBA_StructMember_var::_retn (void)
+ACE_INLINE ::IR::StructMember *
+IR::StructMember_var::_retn (void)
 {
-  CORBA_StructMember *tmp = this->ptr_;
+  ::IR::StructMember *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_StructMember *
-CORBA_StructMember_var::ptr (void) const
+ACE_INLINE ::IR::StructMember *
+IR::StructMember_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_StructMember_out
+// Inline operations for class IR::StructMember_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_StructMember_out::CORBA_StructMember_out (CORBA_StructMember *&p)
+IR::StructMember_out::StructMember_out (::IR::StructMember *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_StructMember_out::CORBA_StructMember_out (CORBA_StructMember_var &p) // constructor from _var
+IR::StructMember_out::StructMember_out (StructMember_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -1713,38 +4898,38 @@ CORBA_StructMember_out::CORBA_StructMember_out (CORBA_StructMember_var &p) // co
 }
 
 ACE_INLINE
-CORBA_StructMember_out::CORBA_StructMember_out (const CORBA_StructMember_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_StructMember_out&,p).ptr_)
+IR::StructMember_out::StructMember_out (const ::IR::StructMember_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (StructMember_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_StructMember_out &
-CORBA_StructMember_out::operator= (const CORBA_StructMember_out &p)
+ACE_INLINE IR::StructMember_out &
+IR::StructMember_out::operator= (const ::IR::StructMember_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_StructMember_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (StructMember_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_StructMember_out &
-CORBA_StructMember_out::operator= (CORBA_StructMember *p)
+ACE_INLINE IR::StructMember_out &
+IR::StructMember_out::operator= (StructMember *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_StructMember_out::operator CORBA_StructMember *&() // cast
+IR::StructMember_out::operator ::IR::StructMember *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMember *&
-CORBA_StructMember_out::ptr (void) // ptr
+ACE_INLINE ::IR::StructMember *&
+IR::StructMember_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMember *
-CORBA_StructMember_out::operator-> (void)
+ACE_INLINE ::IR::StructMember *
+IR::StructMember_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -1752,63 +4937,68 @@ CORBA_StructMember_out::operator-> (void)
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CI_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_STRUCTMEMBERSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_STRUCTMEMBERSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_STRUCTMEMBERSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE CORBA_StructMember *
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE IR::StructMember *
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    CORBA_StructMember *retval = 0;
-    ACE_NEW_RETURN (retval,
-                    CORBA_StructMember[size],
-		    0);
+    IR::StructMember *retval = 0;
+    ACE_NEW_RETURN (retval, IR::StructMember[size], 0);
     return retval;
   }
   
-  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (CORBA_StructMember *buffer)
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (IR::StructMember *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (void) // Default constructor.
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::_TAO_Unbounded_Sequence_IR_StructMemberSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::_TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::_TAO_Unbounded_Sequence_IR_StructMemberSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_StructMember *data,
+    IR::StructMember *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::_TAO_Unbounded_Sequence_CORBA_StructMemberSeq (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::_TAO_Unbounded_Sequence_IR_StructMemberSeq (const _TAO_Unbounded_Sequence_IR_StructMemberSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_StructMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->maximum_);
-    CORBA_StructMember * const tmp2 = ACE_reinterpret_cast (CORBA_StructMember * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    this->buffer_ = tmp1;
+    if (rhs.buffer_ != 0)
+    {
+      IR::StructMember *tmp1 = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (this->maximum_);
+      IR::StructMember * const tmp2 = ACE_reinterpret_cast (IR::StructMember * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_StructMemberSeq &rhs)
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq &
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::operator= (const _TAO_Unbounded_Sequence_IR_StructMemberSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -1819,18 +5009,18 @@ CORBA_StructMember_out::operator-> (void)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        CORBA_StructMember *tmp = ACE_reinterpret_cast (CORBA_StructMember *, this->buffer_);
-        _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (rhs.maximum_);
+        IR::StructMember *tmp = ACE_reinterpret_cast (IR::StructMember *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_StructMember *tmp1 = ACE_reinterpret_cast (CORBA_StructMember *, this->buffer_);
-    CORBA_StructMember * const tmp2 = ACE_reinterpret_cast (CORBA_StructMember * ACE_CAST_CONST, rhs.buffer_);
+    IR::StructMember *tmp1 = ACE_reinterpret_cast (IR::StructMember *, this->buffer_);
+    IR::StructMember * const tmp2 = ACE_reinterpret_cast (IR::StructMember * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -1839,41 +5029,41 @@ CORBA_StructMember_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE CORBA_StructMember &
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE IR::StructMember &
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_StructMember* tmp = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_);
+    IR::StructMember* tmp = ACE_reinterpret_cast(IR::StructMember*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const CORBA_StructMember &
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const IR::StructMember &
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_StructMember * const tmp = ACE_reinterpret_cast (CORBA_StructMember* ACE_CAST_CONST, this->buffer_);
+    IR::StructMember * const tmp = ACE_reinterpret_cast (IR::StructMember* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE CORBA_StructMember *
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::StructMember *
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_StructMember *result = 0;
+    IR::StructMember *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::allocbuf (this->length_);
+        result = _TAO_Unbounded_Sequence_IR_StructMemberSeq::allocbuf (this->length_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_StructMember*, this->buffer_);
+        result = ACE_reinterpret_cast (IR::StructMember*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -1882,7 +5072,7 @@ CORBA_StructMember_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_);
+        result = ACE_reinterpret_cast(IR::StructMember*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -1892,24 +5082,24 @@ CORBA_StructMember_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const CORBA_StructMember *
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::get_buffer (void) const
+  ACE_INLINE const IR::StructMember *
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_StructMember * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::StructMember * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::replace (CORBA::ULong max,
+  IR::_TAO_Unbounded_Sequence_IR_StructMemberSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  CORBA_StructMember *data,
+  IR::StructMember *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      CORBA_StructMember *tmp = ACE_reinterpret_cast(CORBA_StructMember*,this->buffer_);
-      _TAO_Unbounded_Sequence_CORBA_StructMemberSeq::freebuf (tmp);
+      IR::StructMember *tmp = ACE_reinterpret_cast(IR::StructMember*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_StructMemberSeq::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -1920,144 +5110,148 @@ CORBA_StructMember_out::operator-> (void)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_STRUCTMEMBERSEQ_CI_)
-#define _CORBA_STRUCTMEMBERSEQ_CI_
+#if !defined (_IR_STRUCTMEMBERSEQ_CI_)
+#define _IR_STRUCTMEMBERSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_StructMemberSeq_var
+// Inline operations for class IR::StructMemberSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_StructMemberSeq_var::CORBA_StructMemberSeq_var (void) // default constructor
+IR::StructMemberSeq_var::StructMemberSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_StructMemberSeq_var::CORBA_StructMemberSeq_var (CORBA_StructMemberSeq *p)
+IR::StructMemberSeq_var::StructMemberSeq_var (StructMemberSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_StructMemberSeq_var::CORBA_StructMemberSeq_var (const CORBA_StructMemberSeq_var &p) // copy constructor
+IR::StructMemberSeq_var::StructMemberSeq_var (const ::IR::StructMemberSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_StructMemberSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::StructMemberSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_StructMemberSeq_var::~CORBA_StructMemberSeq_var (void) // destructor
+IR::StructMemberSeq_var::~StructMemberSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMemberSeq_var &
-CORBA_StructMemberSeq_var::operator= (CORBA_StructMemberSeq *p)
+ACE_INLINE IR::StructMemberSeq_var &
+IR::StructMemberSeq_var::operator= (StructMemberSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_StructMemberSeq_var &
-CORBA_StructMemberSeq_var::operator= (const CORBA_StructMemberSeq_var &p) // deep copy
+ACE_INLINE IR::StructMemberSeq_var &
+IR::StructMemberSeq_var::operator= (const ::IR::StructMemberSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_StructMemberSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::StructMemberSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_StructMemberSeq *
-CORBA_StructMemberSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::StructMemberSeq *
+IR::StructMemberSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMemberSeq *
-CORBA_StructMemberSeq_var::operator-> (void)
+ACE_INLINE ::IR::StructMemberSeq *
+IR::StructMemberSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StructMemberSeq_var::operator const CORBA_StructMemberSeq &() const // cast
+IR::StructMemberSeq_var::operator const ::IR::StructMemberSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StructMemberSeq_var::operator CORBA_StructMemberSeq &() // cast 
+IR::StructMemberSeq_var::operator ::IR::StructMemberSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StructMemberSeq_var::operator CORBA_StructMemberSeq &() const// cast 
+IR::StructMemberSeq_var::operator ::IR::StructMemberSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMember &
-CORBA_StructMemberSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::StructMemberSeq_var::operator ::IR::StructMemberSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::StructMember &
+IR::StructMemberSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_StructMemberSeq &
-CORBA_StructMemberSeq_var::in (void) const
+ACE_INLINE const ::IR::StructMemberSeq &
+IR::StructMemberSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMemberSeq &
-CORBA_StructMemberSeq_var::inout (void)
+ACE_INLINE ::IR::StructMemberSeq &
+IR::StructMemberSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_StructMemberSeq *&
-CORBA_StructMemberSeq_var::out (void)
+ACE_INLINE ::IR::StructMemberSeq *&
+IR::StructMemberSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMemberSeq *
-CORBA_StructMemberSeq_var::_retn (void)
+ACE_INLINE ::IR::StructMemberSeq *
+IR::StructMemberSeq_var::_retn (void)
 {
-  CORBA_StructMemberSeq *tmp = this->ptr_;
+  ::IR::StructMemberSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_StructMemberSeq *
-CORBA_StructMemberSeq_var::ptr (void) const
+ACE_INLINE ::IR::StructMemberSeq *
+IR::StructMemberSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_StructMemberSeq_out
+// Inline operations for class IR::StructMemberSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_StructMemberSeq_out::CORBA_StructMemberSeq_out (CORBA_StructMemberSeq *&p)
+IR::StructMemberSeq_out::StructMemberSeq_out (StructMemberSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_StructMemberSeq_out::CORBA_StructMemberSeq_out (CORBA_StructMemberSeq_var &p) // constructor from _var
+IR::StructMemberSeq_out::StructMemberSeq_out (StructMemberSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -2065,44 +5259,44 @@ CORBA_StructMemberSeq_out::CORBA_StructMemberSeq_out (CORBA_StructMemberSeq_var
 }
 
 ACE_INLINE
-CORBA_StructMemberSeq_out::CORBA_StructMemberSeq_out (const CORBA_StructMemberSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_StructMemberSeq_out&,p).ptr_)
+IR::StructMemberSeq_out::StructMemberSeq_out (const ::IR::StructMemberSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (StructMemberSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_StructMemberSeq_out &
-CORBA_StructMemberSeq_out::operator= (const CORBA_StructMemberSeq_out &p)
+ACE_INLINE ::IR::StructMemberSeq_out &
+IR::StructMemberSeq_out::operator= (const ::IR::StructMemberSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_StructMemberSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (StructMemberSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_StructMemberSeq_out &
-CORBA_StructMemberSeq_out::operator= (CORBA_StructMemberSeq *p)
+ACE_INLINE ::IR::StructMemberSeq_out &
+IR::StructMemberSeq_out::operator= (StructMemberSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_StructMemberSeq_out::operator CORBA_StructMemberSeq *&() // cast
+IR::StructMemberSeq_out::operator ::IR::StructMemberSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMemberSeq *&
-CORBA_StructMemberSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::StructMemberSeq *&
+IR::StructMemberSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMemberSeq *
-CORBA_StructMemberSeq_out::operator-> (void)
+ACE_INLINE ::IR::StructMemberSeq *
+IR::StructMemberSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructMember &
-CORBA_StructMemberSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE IR::StructMember &
+IR::StructMemberSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -2111,134 +5305,138 @@ CORBA_StructMemberSeq_out::operator[] (CORBA::ULong index)
 #endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA_Initializer_var
+// Inline operations for class IR::Initializer_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_Initializer_var::CORBA_Initializer_var (void) // default constructor
+IR::Initializer_var::Initializer_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_Initializer_var::CORBA_Initializer_var (CORBA_Initializer *p)
+IR::Initializer_var::Initializer_var (Initializer *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_Initializer_var::CORBA_Initializer_var (const CORBA_Initializer_var &p) // copy constructor
+IR::Initializer_var::Initializer_var (const ::IR::Initializer_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_Initializer(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::Initializer (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_Initializer_var::~CORBA_Initializer_var (void) // destructor
+IR::Initializer_var::~Initializer_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_Initializer_var &
-CORBA_Initializer_var::operator= (CORBA_Initializer *p)
+ACE_INLINE IR::Initializer_var &
+IR::Initializer_var::operator= (Initializer *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_Initializer_var &
-CORBA_Initializer_var::operator= (const CORBA_Initializer_var &p)
+ACE_INLINE ::IR::Initializer_var &
+IR::Initializer_var::operator= (const ::IR::Initializer_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_Initializer (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::Initializer (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_Initializer *
-CORBA_Initializer_var::operator-> (void) const
+ACE_INLINE const ::IR::Initializer *
+IR::Initializer_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Initializer *
-CORBA_Initializer_var::operator-> (void)
+ACE_INLINE ::IR::Initializer *
+IR::Initializer_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_Initializer_var::operator const CORBA_Initializer &() const // cast
+ACE_INLINE
+IR::Initializer_var::operator const ::IR::Initializer &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_Initializer_var::operator CORBA_Initializer &() // cast 
+ACE_INLINE
+IR::Initializer_var::operator ::IR::Initializer &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_Initializer_var::operator CORBA_Initializer &() const// cast 
+ACE_INLINE
+IR::Initializer_var::operator ::IR::Initializer &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_Initializer &
-CORBA_Initializer_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::Initializer_var::operator ::IR::Initializer *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::Initializer &
+IR::Initializer_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_Initializer &
-CORBA_Initializer_var::inout (void)
+ACE_INLINE ::IR::Initializer &
+IR::Initializer_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_Initializer *&
-CORBA_Initializer_var::out (void)
+ACE_INLINE ::IR::Initializer *&
+IR::Initializer_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Initializer *
-CORBA_Initializer_var::_retn (void)
+ACE_INLINE ::IR::Initializer *
+IR::Initializer_var::_retn (void)
 {
-  CORBA_Initializer *tmp = this->ptr_;
+  ::IR::Initializer *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_Initializer *
-CORBA_Initializer_var::ptr (void) const
+ACE_INLINE ::IR::Initializer *
+IR::Initializer_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_Initializer_out
+// Inline operations for class IR::Initializer_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_Initializer_out::CORBA_Initializer_out (CORBA_Initializer *&p)
+IR::Initializer_out::Initializer_out (::IR::Initializer *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_Initializer_out::CORBA_Initializer_out (CORBA_Initializer_var &p) // constructor from _var
+IR::Initializer_out::Initializer_out (Initializer_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -2246,38 +5444,38 @@ CORBA_Initializer_out::CORBA_Initializer_out (CORBA_Initializer_var &p) // const
 }
 
 ACE_INLINE
-CORBA_Initializer_out::CORBA_Initializer_out (const CORBA_Initializer_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_Initializer_out&,p).ptr_)
+IR::Initializer_out::Initializer_out (const ::IR::Initializer_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (Initializer_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_Initializer_out &
-CORBA_Initializer_out::operator= (const CORBA_Initializer_out &p)
+ACE_INLINE IR::Initializer_out &
+IR::Initializer_out::operator= (const ::IR::Initializer_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_Initializer_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (Initializer_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_Initializer_out &
-CORBA_Initializer_out::operator= (CORBA_Initializer *p)
+ACE_INLINE IR::Initializer_out &
+IR::Initializer_out::operator= (Initializer *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Initializer_out::operator CORBA_Initializer *&() // cast
+IR::Initializer_out::operator ::IR::Initializer *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Initializer *&
-CORBA_Initializer_out::ptr (void) // ptr
+ACE_INLINE ::IR::Initializer *&
+IR::Initializer_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Initializer *
-CORBA_Initializer_out::operator-> (void)
+ACE_INLINE ::IR::Initializer *
+IR::Initializer_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -2285,63 +5483,68 @@ CORBA_Initializer_out::operator-> (void)
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CI_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_INITIALIZERSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_INITIALIZERSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_INITIALIZERSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE CORBA_Initializer *
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE IR::Initializer *
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    CORBA_Initializer *retval = 0;
-    ACE_NEW_RETURN (retval,
-                    CORBA_Initializer[size],
-		    0);
+    IR::Initializer *retval = 0;
+    ACE_NEW_RETURN (retval, IR::Initializer[size], 0);
     return retval;
   }
   
-  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (CORBA_Initializer *buffer)
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (IR::Initializer *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (void) // Default constructor.
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::_TAO_Unbounded_Sequence_IR_InitializerSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::_TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::_TAO_Unbounded_Sequence_IR_InitializerSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_Initializer *data,
+    IR::Initializer *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::_TAO_Unbounded_Sequence_CORBA_InitializerSeq (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::_TAO_Unbounded_Sequence_IR_InitializerSeq (const _TAO_Unbounded_Sequence_IR_InitializerSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_Initializer *tmp1 = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->maximum_);
-    CORBA_Initializer * const tmp2 = ACE_reinterpret_cast (CORBA_Initializer * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    this->buffer_ = tmp1;
+    if (rhs.buffer_ != 0)
+    {
+      IR::Initializer *tmp1 = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (this->maximum_);
+      IR::Initializer * const tmp2 = ACE_reinterpret_cast (IR::Initializer * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_InitializerSeq &
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_InitializerSeq &rhs)
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_InitializerSeq &
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::operator= (const _TAO_Unbounded_Sequence_IR_InitializerSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -2352,18 +5555,18 @@ CORBA_Initializer_out::operator-> (void)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        CORBA_Initializer *tmp = ACE_reinterpret_cast (CORBA_Initializer *, this->buffer_);
-        _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (rhs.maximum_);
+        IR::Initializer *tmp = ACE_reinterpret_cast (IR::Initializer *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_Initializer *tmp1 = ACE_reinterpret_cast (CORBA_Initializer *, this->buffer_);
-    CORBA_Initializer * const tmp2 = ACE_reinterpret_cast (CORBA_Initializer * ACE_CAST_CONST, rhs.buffer_);
+    IR::Initializer *tmp1 = ACE_reinterpret_cast (IR::Initializer *, this->buffer_);
+    IR::Initializer * const tmp2 = ACE_reinterpret_cast (IR::Initializer * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -2372,41 +5575,41 @@ CORBA_Initializer_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE CORBA_Initializer &
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE IR::Initializer &
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_Initializer* tmp = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_);
+    IR::Initializer* tmp = ACE_reinterpret_cast(IR::Initializer*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const CORBA_Initializer &
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const IR::Initializer &
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_Initializer * const tmp = ACE_reinterpret_cast (CORBA_Initializer* ACE_CAST_CONST, this->buffer_);
+    IR::Initializer * const tmp = ACE_reinterpret_cast (IR::Initializer* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE CORBA_Initializer *
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::Initializer *
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_Initializer *result = 0;
+    IR::Initializer *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Sequence_CORBA_InitializerSeq::allocbuf (this->length_);
+        result = _TAO_Unbounded_Sequence_IR_InitializerSeq::allocbuf (this->length_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_Initializer*, this->buffer_);
+        result = ACE_reinterpret_cast (IR::Initializer*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -2415,7 +5618,7 @@ CORBA_Initializer_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_);
+        result = ACE_reinterpret_cast(IR::Initializer*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -2425,24 +5628,24 @@ CORBA_Initializer_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const CORBA_Initializer *
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::get_buffer (void) const
+  ACE_INLINE const IR::Initializer *
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_Initializer * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::Initializer * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  _TAO_Unbounded_Sequence_CORBA_InitializerSeq::replace (CORBA::ULong max,
+  IR::_TAO_Unbounded_Sequence_IR_InitializerSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  CORBA_Initializer *data,
+  IR::Initializer *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      CORBA_Initializer *tmp = ACE_reinterpret_cast(CORBA_Initializer*,this->buffer_);
-      _TAO_Unbounded_Sequence_CORBA_InitializerSeq::freebuf (tmp);
+      IR::Initializer *tmp = ACE_reinterpret_cast(IR::Initializer*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_InitializerSeq::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -2453,144 +5656,148 @@ CORBA_Initializer_out::operator-> (void)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_INITIALIZERSEQ_CI_)
-#define _CORBA_INITIALIZERSEQ_CI_
+#if !defined (_IR_INITIALIZERSEQ_CI_)
+#define _IR_INITIALIZERSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_InitializerSeq_var
+// Inline operations for class IR::InitializerSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_InitializerSeq_var::CORBA_InitializerSeq_var (void) // default constructor
+IR::InitializerSeq_var::InitializerSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_InitializerSeq_var::CORBA_InitializerSeq_var (CORBA_InitializerSeq *p)
+IR::InitializerSeq_var::InitializerSeq_var (InitializerSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_InitializerSeq_var::CORBA_InitializerSeq_var (const CORBA_InitializerSeq_var &p) // copy constructor
+IR::InitializerSeq_var::InitializerSeq_var (const ::IR::InitializerSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_InitializerSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::InitializerSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_InitializerSeq_var::~CORBA_InitializerSeq_var (void) // destructor
+IR::InitializerSeq_var::~InitializerSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_InitializerSeq_var &
-CORBA_InitializerSeq_var::operator= (CORBA_InitializerSeq *p)
+ACE_INLINE IR::InitializerSeq_var &
+IR::InitializerSeq_var::operator= (InitializerSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_InitializerSeq_var &
-CORBA_InitializerSeq_var::operator= (const CORBA_InitializerSeq_var &p) // deep copy
+ACE_INLINE IR::InitializerSeq_var &
+IR::InitializerSeq_var::operator= (const ::IR::InitializerSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_InitializerSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::InitializerSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_InitializerSeq *
-CORBA_InitializerSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::InitializerSeq *
+IR::InitializerSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InitializerSeq *
-CORBA_InitializerSeq_var::operator-> (void)
+ACE_INLINE ::IR::InitializerSeq *
+IR::InitializerSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_InitializerSeq_var::operator const CORBA_InitializerSeq &() const // cast
+IR::InitializerSeq_var::operator const ::IR::InitializerSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_InitializerSeq_var::operator CORBA_InitializerSeq &() // cast 
+IR::InitializerSeq_var::operator ::IR::InitializerSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_InitializerSeq_var::operator CORBA_InitializerSeq &() const// cast 
+IR::InitializerSeq_var::operator ::IR::InitializerSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_Initializer &
-CORBA_InitializerSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::InitializerSeq_var::operator ::IR::InitializerSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::Initializer &
+IR::InitializerSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_InitializerSeq &
-CORBA_InitializerSeq_var::in (void) const
+ACE_INLINE const ::IR::InitializerSeq &
+IR::InitializerSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_InitializerSeq &
-CORBA_InitializerSeq_var::inout (void)
+ACE_INLINE ::IR::InitializerSeq &
+IR::InitializerSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_InitializerSeq *&
-CORBA_InitializerSeq_var::out (void)
+ACE_INLINE ::IR::InitializerSeq *&
+IR::InitializerSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InitializerSeq *
-CORBA_InitializerSeq_var::_retn (void)
+ACE_INLINE ::IR::InitializerSeq *
+IR::InitializerSeq_var::_retn (void)
 {
-  CORBA_InitializerSeq *tmp = this->ptr_;
+  ::IR::InitializerSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_InitializerSeq *
-CORBA_InitializerSeq_var::ptr (void) const
+ACE_INLINE ::IR::InitializerSeq *
+IR::InitializerSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_InitializerSeq_out
+// Inline operations for class IR::InitializerSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_InitializerSeq_out::CORBA_InitializerSeq_out (CORBA_InitializerSeq *&p)
+IR::InitializerSeq_out::InitializerSeq_out (InitializerSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_InitializerSeq_out::CORBA_InitializerSeq_out (CORBA_InitializerSeq_var &p) // constructor from _var
+IR::InitializerSeq_out::InitializerSeq_out (InitializerSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -2598,44 +5805,44 @@ CORBA_InitializerSeq_out::CORBA_InitializerSeq_out (CORBA_InitializerSeq_var &p)
 }
 
 ACE_INLINE
-CORBA_InitializerSeq_out::CORBA_InitializerSeq_out (const CORBA_InitializerSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_InitializerSeq_out&,p).ptr_)
+IR::InitializerSeq_out::InitializerSeq_out (const ::IR::InitializerSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (InitializerSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_InitializerSeq_out &
-CORBA_InitializerSeq_out::operator= (const CORBA_InitializerSeq_out &p)
+ACE_INLINE ::IR::InitializerSeq_out &
+IR::InitializerSeq_out::operator= (const ::IR::InitializerSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_InitializerSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (InitializerSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_InitializerSeq_out &
-CORBA_InitializerSeq_out::operator= (CORBA_InitializerSeq *p)
+ACE_INLINE ::IR::InitializerSeq_out &
+IR::InitializerSeq_out::operator= (InitializerSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_InitializerSeq_out::operator CORBA_InitializerSeq *&() // cast
+IR::InitializerSeq_out::operator ::IR::InitializerSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InitializerSeq *&
-CORBA_InitializerSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::InitializerSeq *&
+IR::InitializerSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InitializerSeq *
-CORBA_InitializerSeq_out::operator-> (void)
+ACE_INLINE ::IR::InitializerSeq *
+IR::InitializerSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Initializer &
-CORBA_InitializerSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE IR::Initializer &
+IR::InitializerSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -2644,134 +5851,138 @@ CORBA_InitializerSeq_out::operator[] (CORBA::ULong index)
 #endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA_UnionMember_var
+// Inline operations for class IR::UnionMember_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_UnionMember_var::CORBA_UnionMember_var (void) // default constructor
+IR::UnionMember_var::UnionMember_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_UnionMember_var::CORBA_UnionMember_var (CORBA_UnionMember *p)
+IR::UnionMember_var::UnionMember_var (UnionMember *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_UnionMember_var::CORBA_UnionMember_var (const CORBA_UnionMember_var &p) // copy constructor
+IR::UnionMember_var::UnionMember_var (const ::IR::UnionMember_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_UnionMember(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::UnionMember (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_UnionMember_var::~CORBA_UnionMember_var (void) // destructor
+IR::UnionMember_var::~UnionMember_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMember_var &
-CORBA_UnionMember_var::operator= (CORBA_UnionMember *p)
+ACE_INLINE IR::UnionMember_var &
+IR::UnionMember_var::operator= (UnionMember *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_UnionMember_var &
-CORBA_UnionMember_var::operator= (const CORBA_UnionMember_var &p)
+ACE_INLINE ::IR::UnionMember_var &
+IR::UnionMember_var::operator= (const ::IR::UnionMember_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_UnionMember (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::UnionMember (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_UnionMember *
-CORBA_UnionMember_var::operator-> (void) const
+ACE_INLINE const ::IR::UnionMember *
+IR::UnionMember_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMember *
-CORBA_UnionMember_var::operator-> (void)
+ACE_INLINE ::IR::UnionMember *
+IR::UnionMember_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_UnionMember_var::operator const CORBA_UnionMember &() const // cast
+ACE_INLINE
+IR::UnionMember_var::operator const ::IR::UnionMember &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_UnionMember_var::operator CORBA_UnionMember &() // cast 
+ACE_INLINE
+IR::UnionMember_var::operator ::IR::UnionMember &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_UnionMember_var::operator CORBA_UnionMember &() const// cast 
+ACE_INLINE
+IR::UnionMember_var::operator ::IR::UnionMember &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_UnionMember &
-CORBA_UnionMember_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::UnionMember_var::operator ::IR::UnionMember *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::UnionMember &
+IR::UnionMember_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMember &
-CORBA_UnionMember_var::inout (void)
+ACE_INLINE ::IR::UnionMember &
+IR::UnionMember_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_UnionMember *&
-CORBA_UnionMember_var::out (void)
+ACE_INLINE ::IR::UnionMember *&
+IR::UnionMember_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMember *
-CORBA_UnionMember_var::_retn (void)
+ACE_INLINE ::IR::UnionMember *
+IR::UnionMember_var::_retn (void)
 {
-  CORBA_UnionMember *tmp = this->ptr_;
+  ::IR::UnionMember *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_UnionMember *
-CORBA_UnionMember_var::ptr (void) const
+ACE_INLINE ::IR::UnionMember *
+IR::UnionMember_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_UnionMember_out
+// Inline operations for class IR::UnionMember_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_UnionMember_out::CORBA_UnionMember_out (CORBA_UnionMember *&p)
+IR::UnionMember_out::UnionMember_out (::IR::UnionMember *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_UnionMember_out::CORBA_UnionMember_out (CORBA_UnionMember_var &p) // constructor from _var
+IR::UnionMember_out::UnionMember_out (UnionMember_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -2779,38 +5990,38 @@ CORBA_UnionMember_out::CORBA_UnionMember_out (CORBA_UnionMember_var &p) // const
 }
 
 ACE_INLINE
-CORBA_UnionMember_out::CORBA_UnionMember_out (const CORBA_UnionMember_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_UnionMember_out&,p).ptr_)
+IR::UnionMember_out::UnionMember_out (const ::IR::UnionMember_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UnionMember_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_UnionMember_out &
-CORBA_UnionMember_out::operator= (const CORBA_UnionMember_out &p)
+ACE_INLINE IR::UnionMember_out &
+IR::UnionMember_out::operator= (const ::IR::UnionMember_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_UnionMember_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (UnionMember_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_UnionMember_out &
-CORBA_UnionMember_out::operator= (CORBA_UnionMember *p)
+ACE_INLINE IR::UnionMember_out &
+IR::UnionMember_out::operator= (UnionMember *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_UnionMember_out::operator CORBA_UnionMember *&() // cast
+IR::UnionMember_out::operator ::IR::UnionMember *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMember *&
-CORBA_UnionMember_out::ptr (void) // ptr
+ACE_INLINE ::IR::UnionMember *&
+IR::UnionMember_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMember *
-CORBA_UnionMember_out::operator-> (void)
+ACE_INLINE ::IR::UnionMember *
+IR::UnionMember_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -2818,63 +6029,68 @@ CORBA_UnionMember_out::operator-> (void)
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CI_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_UNIONMEMBERSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_UNIONMEMBERSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_UNIONMEMBERSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE CORBA_UnionMember *
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE IR::UnionMember *
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    CORBA_UnionMember *retval = 0;
-    ACE_NEW_RETURN (retval,
-                    CORBA_UnionMember[size],
-		    0);
+    IR::UnionMember *retval = 0;
+    ACE_NEW_RETURN (retval, IR::UnionMember[size], 0);
     return retval;
   }
   
-  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (CORBA_UnionMember *buffer)
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (IR::UnionMember *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (void) // Default constructor.
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::_TAO_Unbounded_Sequence_IR_UnionMemberSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::_TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::_TAO_Unbounded_Sequence_IR_UnionMemberSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_UnionMember *data,
+    IR::UnionMember *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::_TAO_Unbounded_Sequence_CORBA_UnionMemberSeq (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::_TAO_Unbounded_Sequence_IR_UnionMemberSeq (const _TAO_Unbounded_Sequence_IR_UnionMemberSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_UnionMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->maximum_);
-    CORBA_UnionMember * const tmp2 = ACE_reinterpret_cast (CORBA_UnionMember * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    this->buffer_ = tmp1;
+    if (rhs.buffer_ != 0)
+    {
+      IR::UnionMember *tmp1 = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (this->maximum_);
+      IR::UnionMember * const tmp2 = ACE_reinterpret_cast (IR::UnionMember * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq &rhs)
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq &
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::operator= (const _TAO_Unbounded_Sequence_IR_UnionMemberSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -2885,18 +6101,18 @@ CORBA_UnionMember_out::operator-> (void)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        CORBA_UnionMember *tmp = ACE_reinterpret_cast (CORBA_UnionMember *, this->buffer_);
-        _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (rhs.maximum_);
+        IR::UnionMember *tmp = ACE_reinterpret_cast (IR::UnionMember *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_UnionMember *tmp1 = ACE_reinterpret_cast (CORBA_UnionMember *, this->buffer_);
-    CORBA_UnionMember * const tmp2 = ACE_reinterpret_cast (CORBA_UnionMember * ACE_CAST_CONST, rhs.buffer_);
+    IR::UnionMember *tmp1 = ACE_reinterpret_cast (IR::UnionMember *, this->buffer_);
+    IR::UnionMember * const tmp2 = ACE_reinterpret_cast (IR::UnionMember * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -2905,41 +6121,41 @@ CORBA_UnionMember_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE CORBA_UnionMember &
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE IR::UnionMember &
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_UnionMember* tmp = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_);
+    IR::UnionMember* tmp = ACE_reinterpret_cast(IR::UnionMember*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const CORBA_UnionMember &
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const IR::UnionMember &
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_UnionMember * const tmp = ACE_reinterpret_cast (CORBA_UnionMember* ACE_CAST_CONST, this->buffer_);
+    IR::UnionMember * const tmp = ACE_reinterpret_cast (IR::UnionMember* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE CORBA_UnionMember *
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::UnionMember *
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_UnionMember *result = 0;
+    IR::UnionMember *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::allocbuf (this->length_);
+        result = _TAO_Unbounded_Sequence_IR_UnionMemberSeq::allocbuf (this->length_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_UnionMember*, this->buffer_);
+        result = ACE_reinterpret_cast (IR::UnionMember*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -2948,7 +6164,7 @@ CORBA_UnionMember_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_);
+        result = ACE_reinterpret_cast(IR::UnionMember*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -2958,24 +6174,24 @@ CORBA_UnionMember_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const CORBA_UnionMember *
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::get_buffer (void) const
+  ACE_INLINE const IR::UnionMember *
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_UnionMember * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::UnionMember * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::replace (CORBA::ULong max,
+  IR::_TAO_Unbounded_Sequence_IR_UnionMemberSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  CORBA_UnionMember *data,
+  IR::UnionMember *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      CORBA_UnionMember *tmp = ACE_reinterpret_cast(CORBA_UnionMember*,this->buffer_);
-      _TAO_Unbounded_Sequence_CORBA_UnionMemberSeq::freebuf (tmp);
+      IR::UnionMember *tmp = ACE_reinterpret_cast(IR::UnionMember*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_UnionMemberSeq::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -2986,144 +6202,148 @@ CORBA_UnionMember_out::operator-> (void)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_UNIONMEMBERSEQ_CI_)
-#define _CORBA_UNIONMEMBERSEQ_CI_
+#if !defined (_IR_UNIONMEMBERSEQ_CI_)
+#define _IR_UNIONMEMBERSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_UnionMemberSeq_var
+// Inline operations for class IR::UnionMemberSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_UnionMemberSeq_var::CORBA_UnionMemberSeq_var (void) // default constructor
+IR::UnionMemberSeq_var::UnionMemberSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_UnionMemberSeq_var::CORBA_UnionMemberSeq_var (CORBA_UnionMemberSeq *p)
+IR::UnionMemberSeq_var::UnionMemberSeq_var (UnionMemberSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_UnionMemberSeq_var::CORBA_UnionMemberSeq_var (const CORBA_UnionMemberSeq_var &p) // copy constructor
+IR::UnionMemberSeq_var::UnionMemberSeq_var (const ::IR::UnionMemberSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_UnionMemberSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::UnionMemberSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_UnionMemberSeq_var::~CORBA_UnionMemberSeq_var (void) // destructor
+IR::UnionMemberSeq_var::~UnionMemberSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMemberSeq_var &
-CORBA_UnionMemberSeq_var::operator= (CORBA_UnionMemberSeq *p)
+ACE_INLINE IR::UnionMemberSeq_var &
+IR::UnionMemberSeq_var::operator= (UnionMemberSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_UnionMemberSeq_var &
-CORBA_UnionMemberSeq_var::operator= (const CORBA_UnionMemberSeq_var &p) // deep copy
+ACE_INLINE IR::UnionMemberSeq_var &
+IR::UnionMemberSeq_var::operator= (const ::IR::UnionMemberSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_UnionMemberSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::UnionMemberSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_UnionMemberSeq *
-CORBA_UnionMemberSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::UnionMemberSeq *
+IR::UnionMemberSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMemberSeq *
-CORBA_UnionMemberSeq_var::operator-> (void)
+ACE_INLINE ::IR::UnionMemberSeq *
+IR::UnionMemberSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_UnionMemberSeq_var::operator const CORBA_UnionMemberSeq &() const // cast
+IR::UnionMemberSeq_var::operator const ::IR::UnionMemberSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_UnionMemberSeq_var::operator CORBA_UnionMemberSeq &() // cast 
+IR::UnionMemberSeq_var::operator ::IR::UnionMemberSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_UnionMemberSeq_var::operator CORBA_UnionMemberSeq &() const// cast 
+IR::UnionMemberSeq_var::operator ::IR::UnionMemberSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMember &
-CORBA_UnionMemberSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::UnionMemberSeq_var::operator ::IR::UnionMemberSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UnionMember &
+IR::UnionMemberSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_UnionMemberSeq &
-CORBA_UnionMemberSeq_var::in (void) const
+ACE_INLINE const ::IR::UnionMemberSeq &
+IR::UnionMemberSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMemberSeq &
-CORBA_UnionMemberSeq_var::inout (void)
+ACE_INLINE ::IR::UnionMemberSeq &
+IR::UnionMemberSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_UnionMemberSeq *&
-CORBA_UnionMemberSeq_var::out (void)
+ACE_INLINE ::IR::UnionMemberSeq *&
+IR::UnionMemberSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMemberSeq *
-CORBA_UnionMemberSeq_var::_retn (void)
+ACE_INLINE ::IR::UnionMemberSeq *
+IR::UnionMemberSeq_var::_retn (void)
 {
-  CORBA_UnionMemberSeq *tmp = this->ptr_;
+  ::IR::UnionMemberSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_UnionMemberSeq *
-CORBA_UnionMemberSeq_var::ptr (void) const
+ACE_INLINE ::IR::UnionMemberSeq *
+IR::UnionMemberSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_UnionMemberSeq_out
+// Inline operations for class IR::UnionMemberSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_UnionMemberSeq_out::CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq *&p)
+IR::UnionMemberSeq_out::UnionMemberSeq_out (UnionMemberSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_UnionMemberSeq_out::CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq_var &p) // constructor from _var
+IR::UnionMemberSeq_out::UnionMemberSeq_out (UnionMemberSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -3131,44 +6351,44 @@ CORBA_UnionMemberSeq_out::CORBA_UnionMemberSeq_out (CORBA_UnionMemberSeq_var &p)
 }
 
 ACE_INLINE
-CORBA_UnionMemberSeq_out::CORBA_UnionMemberSeq_out (const CORBA_UnionMemberSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_UnionMemberSeq_out&,p).ptr_)
+IR::UnionMemberSeq_out::UnionMemberSeq_out (const ::IR::UnionMemberSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UnionMemberSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_UnionMemberSeq_out &
-CORBA_UnionMemberSeq_out::operator= (const CORBA_UnionMemberSeq_out &p)
+ACE_INLINE ::IR::UnionMemberSeq_out &
+IR::UnionMemberSeq_out::operator= (const ::IR::UnionMemberSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_UnionMemberSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (UnionMemberSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_UnionMemberSeq_out &
-CORBA_UnionMemberSeq_out::operator= (CORBA_UnionMemberSeq *p)
+ACE_INLINE ::IR::UnionMemberSeq_out &
+IR::UnionMemberSeq_out::operator= (UnionMemberSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_UnionMemberSeq_out::operator CORBA_UnionMemberSeq *&() // cast
+IR::UnionMemberSeq_out::operator ::IR::UnionMemberSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMemberSeq *&
-CORBA_UnionMemberSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::UnionMemberSeq *&
+IR::UnionMemberSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMemberSeq *
-CORBA_UnionMemberSeq_out::operator-> (void)
+ACE_INLINE ::IR::UnionMemberSeq *
+IR::UnionMemberSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionMember &
-CORBA_UnionMemberSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE IR::UnionMember &
+IR::UnionMemberSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -3177,144 +6397,148 @@ CORBA_UnionMemberSeq_out::operator[] (CORBA::ULong index)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ENUMMEMBERSEQ_CI_)
-#define _CORBA_ENUMMEMBERSEQ_CI_
+#if !defined (_IR_ENUMMEMBERSEQ_CI_)
+#define _IR_ENUMMEMBERSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_EnumMemberSeq_var
+// Inline operations for class IR::EnumMemberSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_EnumMemberSeq_var::CORBA_EnumMemberSeq_var (void) // default constructor
+IR::EnumMemberSeq_var::EnumMemberSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_EnumMemberSeq_var::CORBA_EnumMemberSeq_var (CORBA_EnumMemberSeq *p)
+IR::EnumMemberSeq_var::EnumMemberSeq_var (EnumMemberSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_EnumMemberSeq_var::CORBA_EnumMemberSeq_var (const CORBA_EnumMemberSeq_var &p) // copy constructor
+IR::EnumMemberSeq_var::EnumMemberSeq_var (const ::IR::EnumMemberSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_EnumMemberSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::EnumMemberSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_EnumMemberSeq_var::~CORBA_EnumMemberSeq_var (void) // destructor
+IR::EnumMemberSeq_var::~EnumMemberSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumMemberSeq_var &
-CORBA_EnumMemberSeq_var::operator= (CORBA_EnumMemberSeq *p)
+ACE_INLINE IR::EnumMemberSeq_var &
+IR::EnumMemberSeq_var::operator= (EnumMemberSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_EnumMemberSeq_var &
-CORBA_EnumMemberSeq_var::operator= (const CORBA_EnumMemberSeq_var &p) // deep copy
+ACE_INLINE IR::EnumMemberSeq_var &
+IR::EnumMemberSeq_var::operator= (const ::IR::EnumMemberSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_EnumMemberSeq (*p.ptr_), 
-	            *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::EnumMemberSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_EnumMemberSeq *
-CORBA_EnumMemberSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::EnumMemberSeq *
+IR::EnumMemberSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumMemberSeq *
-CORBA_EnumMemberSeq_var::operator-> (void)
+ACE_INLINE ::IR::EnumMemberSeq *
+IR::EnumMemberSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_EnumMemberSeq_var::operator const CORBA_EnumMemberSeq &() const // cast
+IR::EnumMemberSeq_var::operator const ::IR::EnumMemberSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_EnumMemberSeq_var::operator CORBA_EnumMemberSeq &() // cast 
+IR::EnumMemberSeq_var::operator ::IR::EnumMemberSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_EnumMemberSeq_var::operator CORBA_EnumMemberSeq &() const// cast 
+IR::EnumMemberSeq_var::operator ::IR::EnumMemberSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
+// variable-size types only
+ACE_INLINE
+IR::EnumMemberSeq_var::operator ::IR::EnumMemberSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
 ACE_INLINE TAO_SeqElem_String_Manager 
-CORBA_EnumMemberSeq_var::operator[] (CORBA::ULong index)
+IR::EnumMemberSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_EnumMemberSeq &
-CORBA_EnumMemberSeq_var::in (void) const
+ACE_INLINE const ::IR::EnumMemberSeq &
+IR::EnumMemberSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumMemberSeq &
-CORBA_EnumMemberSeq_var::inout (void)
+ACE_INLINE ::IR::EnumMemberSeq &
+IR::EnumMemberSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_EnumMemberSeq *&
-CORBA_EnumMemberSeq_var::out (void)
+ACE_INLINE ::IR::EnumMemberSeq *&
+IR::EnumMemberSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumMemberSeq *
-CORBA_EnumMemberSeq_var::_retn (void)
+ACE_INLINE ::IR::EnumMemberSeq *
+IR::EnumMemberSeq_var::_retn (void)
 {
-  CORBA_EnumMemberSeq *tmp = this->ptr_;
+  ::IR::EnumMemberSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_EnumMemberSeq *
-CORBA_EnumMemberSeq_var::ptr (void) const
+ACE_INLINE ::IR::EnumMemberSeq *
+IR::EnumMemberSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_EnumMemberSeq_out
+// Inline operations for class IR::EnumMemberSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_EnumMemberSeq_out::CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq *&p)
+IR::EnumMemberSeq_out::EnumMemberSeq_out (EnumMemberSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_EnumMemberSeq_out::CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq_var &p) // constructor from _var
+IR::EnumMemberSeq_out::EnumMemberSeq_out (EnumMemberSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -3322,44 +6546,44 @@ CORBA_EnumMemberSeq_out::CORBA_EnumMemberSeq_out (CORBA_EnumMemberSeq_var &p) //
 }
 
 ACE_INLINE
-CORBA_EnumMemberSeq_out::CORBA_EnumMemberSeq_out (const CORBA_EnumMemberSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_EnumMemberSeq_out&,p).ptr_)
+IR::EnumMemberSeq_out::EnumMemberSeq_out (const ::IR::EnumMemberSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (EnumMemberSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_EnumMemberSeq_out &
-CORBA_EnumMemberSeq_out::operator= (const CORBA_EnumMemberSeq_out &p)
+ACE_INLINE ::IR::EnumMemberSeq_out &
+IR::EnumMemberSeq_out::operator= (const ::IR::EnumMemberSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_EnumMemberSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (EnumMemberSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_EnumMemberSeq_out &
-CORBA_EnumMemberSeq_out::operator= (CORBA_EnumMemberSeq *p)
+ACE_INLINE ::IR::EnumMemberSeq_out &
+IR::EnumMemberSeq_out::operator= (EnumMemberSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_EnumMemberSeq_out::operator CORBA_EnumMemberSeq *&() // cast
+IR::EnumMemberSeq_out::operator ::IR::EnumMemberSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumMemberSeq *&
-CORBA_EnumMemberSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::EnumMemberSeq *&
+IR::EnumMemberSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumMemberSeq *
-CORBA_EnumMemberSeq_out::operator-> (void)
+ACE_INLINE ::IR::EnumMemberSeq *
+IR::EnumMemberSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_String_Manager 
-CORBA_EnumMemberSeq_out::operator[] (CORBA::ULong index)
+IR::EnumMemberSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -3368,116 +6592,116 @@ CORBA_EnumMemberSeq_out::operator[] (CORBA::ULong index)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_Container::CORBA_Container (void) // default constructor
+IR::Container::Container (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_Container::CORBA_Container (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::Container::Container (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_Container::~CORBA_Container (void) // destructor
+IR::Container::~Container (void) // destructor
 {}
 
 
-#if !defined (_CORBA_CONTAINER___VAR_CI_)
-#define _CORBA_CONTAINER___VAR_CI_
+#if !defined (_IR_CONTAINER___VAR_CI_)
+#define _IR_CONTAINER___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_Container_var
+// Inline operations for class IR::Container_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_Container_var::CORBA_Container_var (void) // default constructor
-  : ptr_ (CORBA_Container::_nil ())
+IR::Container_var::Container_var (void) // default constructor
+  : ptr_ (Container::_nil ())
 {}
 
 ACE_INLINE
-CORBA_Container_var::CORBA_Container_var (CORBA_Container_ptr p)
+IR::Container_var::Container_var (Container_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_Container_ptr 
-CORBA_Container_var::ptr (void) const
+ACE_INLINE ::IR::Container_ptr
+IR::Container_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_Container_var::CORBA_Container_var (const CORBA_Container_var &p) // copy constructor
-  : ptr_ (CORBA_Container::_duplicate (p.ptr ()))
+IR::Container_var::Container_var (const ::IR::Container_var &p) // copy constructor
+  : ptr_ (Container::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_Container_var::~CORBA_Container_var (void) // destructor
+IR::Container_var::~Container_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_Container_var &
-CORBA_Container_var::operator= (CORBA_Container_ptr p)
+ACE_INLINE IR::Container_var &
+IR::Container_var::operator= (Container_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_Container_var &
-CORBA_Container_var::operator= (const CORBA_Container_var &p)
+ACE_INLINE IR::Container_var &
+IR::Container_var::operator= (const ::IR::Container_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_Container::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::Container::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Container_var::operator const CORBA_Container_ptr &() const // cast
+IR::Container_var::operator const ::IR::Container_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_Container_var::operator CORBA_Container_ptr &() // cast 
+IR::Container_var::operator ::IR::Container_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container_ptr 
-CORBA_Container_var::operator-> (void) const
+ACE_INLINE ::IR::Container_ptr
+IR::Container_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container_ptr
-CORBA_Container_var::in (void) const
+ACE_INLINE ::IR::Container_ptr
+IR::Container_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container_ptr &
-CORBA_Container_var::inout (void)
+ACE_INLINE ::IR::Container_ptr &
+IR::Container_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container_ptr &
-CORBA_Container_var::out (void)
+ACE_INLINE ::IR::Container_ptr &
+IR::Container_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_Container::_nil ();
+  this->ptr_ = ::IR::Container::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container_ptr 
-CORBA_Container_var::_retn (void)
+ACE_INLINE ::IR::Container_ptr
+IR::Container_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_Container_ptr val = this->ptr_;
-  this->ptr_ = CORBA_Container::_nil ();
+  ::IR::Container_ptr val = this->ptr_;
+  this->ptr_ = ::IR::Container::_nil ();
   return val;
 }
 
@@ -3485,68 +6709,68 @@ CORBA_Container_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTAINER___OUT_CI_)
-#define _CORBA_CONTAINER___OUT_CI_
+#if !defined (_IR_CONTAINER___OUT_CI_)
+#define _IR_CONTAINER___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_Container_out
+// Inline operations for class IR::Container_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_Container_out::CORBA_Container_out (CORBA_Container_ptr &p)
+IR::Container_out::Container_out (Container_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_Container::_nil ();
+  this->ptr_ = ::IR::Container::_nil ();
 }
 
 ACE_INLINE
-CORBA_Container_out::CORBA_Container_out (CORBA_Container_var &p) // constructor from _var
+IR::Container_out::Container_out (Container_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_Container::_nil ();
+  this->ptr_ = ::IR::Container::_nil ();
 }
 
 ACE_INLINE
-CORBA_Container_out::CORBA_Container_out (const CORBA_Container_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_Container_out&,p).ptr_)
+IR::Container_out::Container_out (const ::IR::Container_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (Container_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_Container_out &
-CORBA_Container_out::operator= (const CORBA_Container_out &p)
+ACE_INLINE ::IR::Container_out &
+IR::Container_out::operator= (const ::IR::Container_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_Container_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (Container_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_Container_out &
-CORBA_Container_out::operator= (const CORBA_Container_var &p)
+ACE_INLINE IR::Container_out &
+IR::Container_out::operator= (const ::IR::Container_var &p)
 {
-  this->ptr_ = CORBA_Container::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::Container::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_Container_out &
-CORBA_Container_out::operator= (CORBA_Container_ptr p)
+ACE_INLINE IR::Container_out &
+IR::Container_out::operator= (Container_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Container_out::operator CORBA_Container_ptr &() // cast
+IR::Container_out::operator ::IR::Container_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container_ptr &
-CORBA_Container_out::ptr (void) // ptr
+ACE_INLINE ::IR::Container_ptr &
+IR::Container_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container_ptr 
-CORBA_Container_out::operator-> (void)
+ACE_INLINE ::IR::Container_ptr
+IR::Container_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -3555,134 +6779,138 @@ CORBA_Container_out::operator-> (void)
 #endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA_Container::Description_var
+// Inline operations for class IR::Container::Description_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_Container::Description_var::Description_var (void) // default constructor
+IR::Container::Description_var::Description_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_Container::Description_var::Description_var (CORBA_Container::Description *p)
+IR::Container::Description_var::Description_var (Description *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_Container::Description_var::Description_var (const CORBA_Container::Description_var &p) // copy constructor
+IR::Container::Description_var::Description_var (const ::IR::Container::Description_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_Container::Description(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::Container::Description (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_Container::Description_var::~Description_var (void) // destructor
+IR::Container::Description_var::~Description_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::Description_var &
-CORBA_Container::Description_var::operator= (CORBA_Container::Description *p)
+ACE_INLINE IR::Container::Description_var &
+IR::Container::Description_var::operator= (Description *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_Container::Description_var &
-CORBA_Container::Description_var::operator= (const CORBA_Container::Description_var &p)
+ACE_INLINE ::IR::Container::Description_var &
+IR::Container::Description_var::operator= (const ::IR::Container::Description_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_Container::Description (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::Container::Description (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_Container::Description *
-CORBA_Container::Description_var::operator-> (void) const
+ACE_INLINE const ::IR::Container::Description *
+IR::Container::Description_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::Description *
-CORBA_Container::Description_var::operator-> (void)
+ACE_INLINE ::IR::Container::Description *
+IR::Container::Description_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_Container::Description_var::operator const CORBA_Container::Description &() const // cast
+ACE_INLINE
+IR::Container::Description_var::operator const ::IR::Container::Description &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_Container::Description_var::operator CORBA_Container::Description &() // cast 
+ACE_INLINE
+IR::Container::Description_var::operator ::IR::Container::Description &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_Container::Description_var::operator CORBA_Container::Description &() const// cast 
+ACE_INLINE
+IR::Container::Description_var::operator ::IR::Container::Description &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_Container::Description &
-CORBA_Container::Description_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::Container::Description_var::operator ::IR::Container::Description *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::Container::Description &
+IR::Container::Description_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::Description &
-CORBA_Container::Description_var::inout (void)
+ACE_INLINE ::IR::Container::Description &
+IR::Container::Description_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_Container::Description *&
-CORBA_Container::Description_var::out (void)
+ACE_INLINE ::IR::Container::Description *&
+IR::Container::Description_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::Description *
-CORBA_Container::Description_var::_retn (void)
+ACE_INLINE ::IR::Container::Description *
+IR::Container::Description_var::_retn (void)
 {
-  CORBA_Container::Description *tmp = this->ptr_;
+  ::IR::Container::Description *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_Container::Description *
-CORBA_Container::Description_var::ptr (void) const
+ACE_INLINE ::IR::Container::Description *
+IR::Container::Description_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_Container::Description_out
+// Inline operations for class IR::Container::Description_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_Container::Description_out::Description_out (CORBA_Container::Description *&p)
+IR::Container::Description_out::Description_out (::IR::Container::Description *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_Container::Description_out::Description_out (CORBA_Container::Description_var &p) // constructor from _var
+IR::Container::Description_out::Description_out (Description_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -3690,38 +6918,38 @@ CORBA_Container::Description_out::Description_out (CORBA_Container::Description_
 }
 
 ACE_INLINE
-CORBA_Container::Description_out::Description_out (const CORBA_Container::Description_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_Container::Description_out&,p).ptr_)
+IR::Container::Description_out::Description_out (const ::IR::Container::Description_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (Description_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_Container::Description_out &
-CORBA_Container::Description_out::operator= (const CORBA_Container::Description_out &p)
+ACE_INLINE IR::Container::Description_out &
+IR::Container::Description_out::operator= (const ::IR::Container::Description_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_Container::Description_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (Description_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_Container::Description_out &
-CORBA_Container::Description_out::operator= (CORBA_Container::Description *p)
+ACE_INLINE IR::Container::Description_out &
+IR::Container::Description_out::operator= (Description *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Container::Description_out::operator CORBA_Container::Description *&() // cast
+IR::Container::Description_out::operator ::IR::Container::Description *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::Description *&
-CORBA_Container::Description_out::ptr (void) // ptr
+ACE_INLINE ::IR::Container::Description *&
+IR::Container::Description_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::Description *
-CORBA_Container::Description_out::operator-> (void)
+ACE_INLINE ::IR::Container::Description *
+IR::Container::Description_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -3729,63 +6957,68 @@ CORBA_Container::Description_out::operator-> (void)
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_CONTAINER_DESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_CONTAINER_DESCRIPTIONSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE CORBA_Container::Description *
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE IR::Container::Description *
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    CORBA_Container::Description *retval = 0;
-    ACE_NEW_RETURN (retval,
-                    CORBA_Container::Description[size],
-		    0);
+    IR::Container::Description *retval = 0;
+    ACE_NEW_RETURN (retval, IR::Container::Description[size], 0);
     return retval;
   }
   
-  ACE_INLINE void CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (CORBA_Container::Description *buffer)
+  ACE_INLINE void IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (IR::Container::Description *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (void) // Default constructor.
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (maximum))
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (CORBA::ULong maximum,
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_Container::Description *data,
+    IR::Container::Description *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq (const CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs)
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq (const _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_Container::Description *tmp1 = CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (this->maximum_);
-    CORBA_Container::Description * const tmp2 = ACE_reinterpret_cast (CORBA_Container::Description * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    this->buffer_ = tmp1;
+    if (rhs.buffer_ != 0)
+    {
+      IR::Container::Description *tmp1 = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (this->maximum_);
+      IR::Container::Description * const tmp2 = ACE_reinterpret_cast (IR::Container::Description * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator= (const CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq &rhs)
+  ACE_INLINE IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -3796,18 +7029,18 @@ CORBA_Container::Description_out::operator-> (void)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        CORBA_Container::Description *tmp = ACE_reinterpret_cast (CORBA_Container::Description *, this->buffer_);
-        CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
-        this->buffer_ = CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (rhs.maximum_);
+        IR::Container::Description *tmp = ACE_reinterpret_cast (IR::Container::Description *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_Container::Description *tmp1 = ACE_reinterpret_cast (CORBA_Container::Description *, this->buffer_);
-    CORBA_Container::Description * const tmp2 = ACE_reinterpret_cast (CORBA_Container::Description * ACE_CAST_CONST, rhs.buffer_);
+    IR::Container::Description *tmp1 = ACE_reinterpret_cast (IR::Container::Description *, this->buffer_);
+    IR::Container::Description * const tmp2 = ACE_reinterpret_cast (IR::Container::Description * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -3816,41 +7049,41 @@ CORBA_Container::Description_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE CORBA_Container::Description &
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE IR::Container::Description &
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_Container::Description* tmp = ACE_reinterpret_cast(CORBA_Container::Description*,this->buffer_);
+    IR::Container::Description* tmp = ACE_reinterpret_cast(IR::Container::Description*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const CORBA_Container::Description &
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const IR::Container::Description &
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_Container::Description * const tmp = ACE_reinterpret_cast (CORBA_Container::Description* ACE_CAST_CONST, this->buffer_);
+    IR::Container::Description * const tmp = ACE_reinterpret_cast (IR::Container::Description* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE CORBA_Container::Description *
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::Container::Description *
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_Container::Description *result = 0;
+    IR::Container::Description *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::allocbuf (this->length_);
+        result = _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::allocbuf (this->length_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_Container::Description*, this->buffer_);
+        result = ACE_reinterpret_cast (IR::Container::Description*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -3859,7 +7092,7 @@ CORBA_Container::Description_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_Container::Description*,this->buffer_);
+        result = ACE_reinterpret_cast(IR::Container::Description*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -3869,24 +7102,24 @@ CORBA_Container::Description_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const CORBA_Container::Description *
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::get_buffer (void) const
+  ACE_INLINE const IR::Container::Description *
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_Container::Description * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::Container::Description * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::replace (CORBA::ULong max,
+  IR::Container::_TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  CORBA_Container::Description *data,
+  IR::Container::Description *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      CORBA_Container::Description *tmp = ACE_reinterpret_cast(CORBA_Container::Description*,this->buffer_);
-      CORBA_Container::_TAO_Unbounded_Sequence_CORBA_Container_DescriptionSeq::freebuf (tmp);
+      IR::Container::Description *tmp = ACE_reinterpret_cast(IR::Container::Description*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_Container_DescriptionSeq::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -3897,144 +7130,148 @@ CORBA_Container::Description_out::operator-> (void)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_CONTAINER_DESCRIPTIONSEQ_CI_)
-#define _CORBA_CONTAINER_DESCRIPTIONSEQ_CI_
+#if !defined (_IR_CONTAINER_DESCRIPTIONSEQ_CI_)
+#define _IR_CONTAINER_DESCRIPTIONSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_Container::DescriptionSeq_var
+// Inline operations for class IR::Container::DescriptionSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_Container::DescriptionSeq_var::DescriptionSeq_var (void) // default constructor
+IR::Container::DescriptionSeq_var::DescriptionSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_Container::DescriptionSeq_var::DescriptionSeq_var (CORBA_Container::DescriptionSeq *p)
+IR::Container::DescriptionSeq_var::DescriptionSeq_var (DescriptionSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_Container::DescriptionSeq_var::DescriptionSeq_var (const CORBA_Container::DescriptionSeq_var &p) // copy constructor
+IR::Container::DescriptionSeq_var::DescriptionSeq_var (const ::IR::Container::DescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_Container::DescriptionSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::Container::DescriptionSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_Container::DescriptionSeq_var::~DescriptionSeq_var (void) // destructor
+IR::Container::DescriptionSeq_var::~DescriptionSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::DescriptionSeq_var &
-CORBA_Container::DescriptionSeq_var::operator= (CORBA_Container::DescriptionSeq *p)
+ACE_INLINE IR::Container::DescriptionSeq_var &
+IR::Container::DescriptionSeq_var::operator= (DescriptionSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_Container::DescriptionSeq_var &
-CORBA_Container::DescriptionSeq_var::operator= (const CORBA_Container::DescriptionSeq_var &p) // deep copy
+ACE_INLINE IR::Container::DescriptionSeq_var &
+IR::Container::DescriptionSeq_var::operator= (const ::IR::Container::DescriptionSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_Container::DescriptionSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::Container::DescriptionSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_Container::DescriptionSeq *
-CORBA_Container::DescriptionSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::Container::DescriptionSeq *
+IR::Container::DescriptionSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::DescriptionSeq *
-CORBA_Container::DescriptionSeq_var::operator-> (void)
+ACE_INLINE ::IR::Container::DescriptionSeq *
+IR::Container::DescriptionSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_Container::DescriptionSeq_var::operator const CORBA_Container::DescriptionSeq &() const // cast
+IR::Container::DescriptionSeq_var::operator const ::IR::Container::DescriptionSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_Container::DescriptionSeq_var::operator CORBA_Container::DescriptionSeq &() // cast 
+IR::Container::DescriptionSeq_var::operator ::IR::Container::DescriptionSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_Container::DescriptionSeq_var::operator CORBA_Container::DescriptionSeq &() const// cast 
+IR::Container::DescriptionSeq_var::operator ::IR::Container::DescriptionSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::Description &
-CORBA_Container::DescriptionSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::Container::DescriptionSeq_var::operator ::IR::Container::DescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::Container::Description &
+IR::Container::DescriptionSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_Container::DescriptionSeq &
-CORBA_Container::DescriptionSeq_var::in (void) const
+ACE_INLINE const ::IR::Container::DescriptionSeq &
+IR::Container::DescriptionSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::DescriptionSeq &
-CORBA_Container::DescriptionSeq_var::inout (void)
+ACE_INLINE ::IR::Container::DescriptionSeq &
+IR::Container::DescriptionSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_Container::DescriptionSeq *&
-CORBA_Container::DescriptionSeq_var::out (void)
+ACE_INLINE ::IR::Container::DescriptionSeq *&
+IR::Container::DescriptionSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::DescriptionSeq *
-CORBA_Container::DescriptionSeq_var::_retn (void)
+ACE_INLINE ::IR::Container::DescriptionSeq *
+IR::Container::DescriptionSeq_var::_retn (void)
 {
-  CORBA_Container::DescriptionSeq *tmp = this->ptr_;
+  ::IR::Container::DescriptionSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_Container::DescriptionSeq *
-CORBA_Container::DescriptionSeq_var::ptr (void) const
+ACE_INLINE ::IR::Container::DescriptionSeq *
+IR::Container::DescriptionSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_Container::DescriptionSeq_out
+// Inline operations for class IR::Container::DescriptionSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_Container::DescriptionSeq_out::DescriptionSeq_out (CORBA_Container::DescriptionSeq *&p)
+IR::Container::DescriptionSeq_out::DescriptionSeq_out (DescriptionSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_Container::DescriptionSeq_out::DescriptionSeq_out (CORBA_Container::DescriptionSeq_var &p) // constructor from _var
+IR::Container::DescriptionSeq_out::DescriptionSeq_out (DescriptionSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -4042,44 +7279,44 @@ CORBA_Container::DescriptionSeq_out::DescriptionSeq_out (CORBA_Container::Descri
 }
 
 ACE_INLINE
-CORBA_Container::DescriptionSeq_out::DescriptionSeq_out (const CORBA_Container::DescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_Container::DescriptionSeq_out&,p).ptr_)
+IR::Container::DescriptionSeq_out::DescriptionSeq_out (const ::IR::Container::DescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (DescriptionSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_Container::DescriptionSeq_out &
-CORBA_Container::DescriptionSeq_out::operator= (const CORBA_Container::DescriptionSeq_out &p)
+ACE_INLINE ::IR::Container::DescriptionSeq_out &
+IR::Container::DescriptionSeq_out::operator= (const ::IR::Container::DescriptionSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_Container::DescriptionSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (DescriptionSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_Container::DescriptionSeq_out &
-CORBA_Container::DescriptionSeq_out::operator= (CORBA_Container::DescriptionSeq *p)
+ACE_INLINE ::IR::Container::DescriptionSeq_out &
+IR::Container::DescriptionSeq_out::operator= (DescriptionSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Container::DescriptionSeq_out::operator CORBA_Container::DescriptionSeq *&() // cast
+IR::Container::DescriptionSeq_out::operator ::IR::Container::DescriptionSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::DescriptionSeq *&
-CORBA_Container::DescriptionSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::Container::DescriptionSeq *&
+IR::Container::DescriptionSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::DescriptionSeq *
-CORBA_Container::DescriptionSeq_out::operator-> (void)
+ACE_INLINE ::IR::Container::DescriptionSeq *
+IR::Container::DescriptionSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Container::Description &
-CORBA_Container::DescriptionSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE IR::Container::Description &
+IR::Container::DescriptionSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -4088,116 +7325,116 @@ CORBA_Container::DescriptionSeq_out::operator[] (CORBA::ULong index)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_IDLType::CORBA_IDLType (void) // default constructor
+IR::IDLType::IDLType (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_IDLType::CORBA_IDLType (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::IDLType::IDLType (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_IDLType::~CORBA_IDLType (void) // destructor
+IR::IDLType::~IDLType (void) // destructor
 {}
 
 
-#if !defined (_CORBA_IDLTYPE___VAR_CI_)
-#define _CORBA_IDLTYPE___VAR_CI_
+#if !defined (_IR_IDLTYPE___VAR_CI_)
+#define _IR_IDLTYPE___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_IDLType_var
+// Inline operations for class IR::IDLType_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_IDLType_var::CORBA_IDLType_var (void) // default constructor
-  : ptr_ (CORBA_IDLType::_nil ())
+IR::IDLType_var::IDLType_var (void) // default constructor
+  : ptr_ (IDLType::_nil ())
 {}
 
 ACE_INLINE
-CORBA_IDLType_var::CORBA_IDLType_var (CORBA_IDLType_ptr p)
+IR::IDLType_var::IDLType_var (IDLType_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_IDLType_ptr 
-CORBA_IDLType_var::ptr (void) const
+ACE_INLINE ::IR::IDLType_ptr
+IR::IDLType_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_IDLType_var::CORBA_IDLType_var (const CORBA_IDLType_var &p) // copy constructor
-  : ptr_ (CORBA_IDLType::_duplicate (p.ptr ()))
+IR::IDLType_var::IDLType_var (const ::IR::IDLType_var &p) // copy constructor
+  : ptr_ (IDLType::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_IDLType_var::~CORBA_IDLType_var (void) // destructor
+IR::IDLType_var::~IDLType_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_IDLType_var &
-CORBA_IDLType_var::operator= (CORBA_IDLType_ptr p)
+ACE_INLINE IR::IDLType_var &
+IR::IDLType_var::operator= (IDLType_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_IDLType_var &
-CORBA_IDLType_var::operator= (const CORBA_IDLType_var &p)
+ACE_INLINE IR::IDLType_var &
+IR::IDLType_var::operator= (const ::IR::IDLType_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_IDLType::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::IDLType::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_IDLType_var::operator const CORBA_IDLType_ptr &() const // cast
+IR::IDLType_var::operator const ::IR::IDLType_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_IDLType_var::operator CORBA_IDLType_ptr &() // cast 
+IR::IDLType_var::operator ::IR::IDLType_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_IDLType_ptr 
-CORBA_IDLType_var::operator-> (void) const
+ACE_INLINE ::IR::IDLType_ptr
+IR::IDLType_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_IDLType_ptr
-CORBA_IDLType_var::in (void) const
+ACE_INLINE ::IR::IDLType_ptr
+IR::IDLType_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_IDLType_ptr &
-CORBA_IDLType_var::inout (void)
+ACE_INLINE ::IR::IDLType_ptr &
+IR::IDLType_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_IDLType_ptr &
-CORBA_IDLType_var::out (void)
+ACE_INLINE ::IR::IDLType_ptr &
+IR::IDLType_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_IDLType::_nil ();
+  this->ptr_ = ::IR::IDLType::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_IDLType_ptr 
-CORBA_IDLType_var::_retn (void)
+ACE_INLINE ::IR::IDLType_ptr
+IR::IDLType_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_IDLType_ptr val = this->ptr_;
-  this->ptr_ = CORBA_IDLType::_nil ();
+  ::IR::IDLType_ptr val = this->ptr_;
+  this->ptr_ = ::IR::IDLType::_nil ();
   return val;
 }
 
@@ -4205,68 +7442,68 @@ CORBA_IDLType_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_IDLTYPE___OUT_CI_)
-#define _CORBA_IDLTYPE___OUT_CI_
+#if !defined (_IR_IDLTYPE___OUT_CI_)
+#define _IR_IDLTYPE___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_IDLType_out
+// Inline operations for class IR::IDLType_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_IDLType_out::CORBA_IDLType_out (CORBA_IDLType_ptr &p)
+IR::IDLType_out::IDLType_out (IDLType_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_IDLType::_nil ();
+  this->ptr_ = ::IR::IDLType::_nil ();
 }
 
 ACE_INLINE
-CORBA_IDLType_out::CORBA_IDLType_out (CORBA_IDLType_var &p) // constructor from _var
+IR::IDLType_out::IDLType_out (IDLType_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_IDLType::_nil ();
+  this->ptr_ = ::IR::IDLType::_nil ();
 }
 
 ACE_INLINE
-CORBA_IDLType_out::CORBA_IDLType_out (const CORBA_IDLType_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_IDLType_out&,p).ptr_)
+IR::IDLType_out::IDLType_out (const ::IR::IDLType_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (IDLType_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_IDLType_out &
-CORBA_IDLType_out::operator= (const CORBA_IDLType_out &p)
+ACE_INLINE ::IR::IDLType_out &
+IR::IDLType_out::operator= (const ::IR::IDLType_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_IDLType_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (IDLType_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_IDLType_out &
-CORBA_IDLType_out::operator= (const CORBA_IDLType_var &p)
+ACE_INLINE IR::IDLType_out &
+IR::IDLType_out::operator= (const ::IR::IDLType_var &p)
 {
-  this->ptr_ = CORBA_IDLType::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::IDLType::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_IDLType_out &
-CORBA_IDLType_out::operator= (CORBA_IDLType_ptr p)
+ACE_INLINE IR::IDLType_out &
+IR::IDLType_out::operator= (IDLType_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_IDLType_out::operator CORBA_IDLType_ptr &() // cast
+IR::IDLType_out::operator ::IR::IDLType_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_IDLType_ptr &
-CORBA_IDLType_out::ptr (void) // ptr
+ACE_INLINE ::IR::IDLType_ptr &
+IR::IDLType_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_IDLType_ptr 
-CORBA_IDLType_out::operator-> (void)
+ACE_INLINE ::IR::IDLType_ptr
+IR::IDLType_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -4275,116 +7512,116 @@ CORBA_IDLType_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_Repository::CORBA_Repository (void) // default constructor
+IR::Repository::Repository (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_Repository::CORBA_Repository (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::Repository::Repository (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_Repository::~CORBA_Repository (void) // destructor
+IR::Repository::~Repository (void) // destructor
 {}
 
 
-#if !defined (_CORBA_REPOSITORY___VAR_CI_)
-#define _CORBA_REPOSITORY___VAR_CI_
+#if !defined (_IR_REPOSITORY___VAR_CI_)
+#define _IR_REPOSITORY___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_Repository_var
+// Inline operations for class IR::Repository_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_Repository_var::CORBA_Repository_var (void) // default constructor
-  : ptr_ (CORBA_Repository::_nil ())
+IR::Repository_var::Repository_var (void) // default constructor
+  : ptr_ (Repository::_nil ())
 {}
 
 ACE_INLINE
-CORBA_Repository_var::CORBA_Repository_var (CORBA_Repository_ptr p)
+IR::Repository_var::Repository_var (Repository_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_Repository_ptr 
-CORBA_Repository_var::ptr (void) const
+ACE_INLINE ::IR::Repository_ptr
+IR::Repository_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_Repository_var::CORBA_Repository_var (const CORBA_Repository_var &p) // copy constructor
-  : ptr_ (CORBA_Repository::_duplicate (p.ptr ()))
+IR::Repository_var::Repository_var (const ::IR::Repository_var &p) // copy constructor
+  : ptr_ (Repository::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_Repository_var::~CORBA_Repository_var (void) // destructor
+IR::Repository_var::~Repository_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_Repository_var &
-CORBA_Repository_var::operator= (CORBA_Repository_ptr p)
+ACE_INLINE IR::Repository_var &
+IR::Repository_var::operator= (Repository_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_Repository_var &
-CORBA_Repository_var::operator= (const CORBA_Repository_var &p)
+ACE_INLINE IR::Repository_var &
+IR::Repository_var::operator= (const ::IR::Repository_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_Repository::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::Repository::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Repository_var::operator const CORBA_Repository_ptr &() const // cast
+IR::Repository_var::operator const ::IR::Repository_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_Repository_var::operator CORBA_Repository_ptr &() // cast 
+IR::Repository_var::operator ::IR::Repository_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Repository_ptr 
-CORBA_Repository_var::operator-> (void) const
+ACE_INLINE ::IR::Repository_ptr
+IR::Repository_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Repository_ptr
-CORBA_Repository_var::in (void) const
+ACE_INLINE ::IR::Repository_ptr
+IR::Repository_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Repository_ptr &
-CORBA_Repository_var::inout (void)
+ACE_INLINE ::IR::Repository_ptr &
+IR::Repository_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Repository_ptr &
-CORBA_Repository_var::out (void)
+ACE_INLINE ::IR::Repository_ptr &
+IR::Repository_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_Repository::_nil ();
+  this->ptr_ = ::IR::Repository::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Repository_ptr 
-CORBA_Repository_var::_retn (void)
+ACE_INLINE ::IR::Repository_ptr
+IR::Repository_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_Repository_ptr val = this->ptr_;
-  this->ptr_ = CORBA_Repository::_nil ();
+  ::IR::Repository_ptr val = this->ptr_;
+  this->ptr_ = ::IR::Repository::_nil ();
   return val;
 }
 
@@ -4392,68 +7629,68 @@ CORBA_Repository_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_REPOSITORY___OUT_CI_)
-#define _CORBA_REPOSITORY___OUT_CI_
+#if !defined (_IR_REPOSITORY___OUT_CI_)
+#define _IR_REPOSITORY___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_Repository_out
+// Inline operations for class IR::Repository_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_Repository_out::CORBA_Repository_out (CORBA_Repository_ptr &p)
+IR::Repository_out::Repository_out (Repository_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_Repository::_nil ();
+  this->ptr_ = ::IR::Repository::_nil ();
 }
 
 ACE_INLINE
-CORBA_Repository_out::CORBA_Repository_out (CORBA_Repository_var &p) // constructor from _var
+IR::Repository_out::Repository_out (Repository_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_Repository::_nil ();
+  this->ptr_ = ::IR::Repository::_nil ();
 }
 
 ACE_INLINE
-CORBA_Repository_out::CORBA_Repository_out (const CORBA_Repository_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_Repository_out&,p).ptr_)
+IR::Repository_out::Repository_out (const ::IR::Repository_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (Repository_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_Repository_out &
-CORBA_Repository_out::operator= (const CORBA_Repository_out &p)
+ACE_INLINE ::IR::Repository_out &
+IR::Repository_out::operator= (const ::IR::Repository_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_Repository_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (Repository_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_Repository_out &
-CORBA_Repository_out::operator= (const CORBA_Repository_var &p)
+ACE_INLINE IR::Repository_out &
+IR::Repository_out::operator= (const ::IR::Repository_var &p)
 {
-  this->ptr_ = CORBA_Repository::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::Repository::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_Repository_out &
-CORBA_Repository_out::operator= (CORBA_Repository_ptr p)
+ACE_INLINE IR::Repository_out &
+IR::Repository_out::operator= (Repository_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_Repository_out::operator CORBA_Repository_ptr &() // cast
+IR::Repository_out::operator ::IR::Repository_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Repository_ptr &
-CORBA_Repository_out::ptr (void) // ptr
+ACE_INLINE ::IR::Repository_ptr &
+IR::Repository_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_Repository_ptr 
-CORBA_Repository_out::operator-> (void)
+ACE_INLINE ::IR::Repository_ptr
+IR::Repository_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -4462,116 +7699,116 @@ CORBA_Repository_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_ModuleDef::CORBA_ModuleDef (void) // default constructor
+IR::ComponentRepository::ComponentRepository (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_ModuleDef::CORBA_ModuleDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::ComponentRepository::ComponentRepository (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_ModuleDef::~CORBA_ModuleDef (void) // destructor
+IR::ComponentRepository::~ComponentRepository (void) // destructor
 {}
 
 
-#if !defined (_CORBA_MODULEDEF___VAR_CI_)
-#define _CORBA_MODULEDEF___VAR_CI_
+#if !defined (_IR_COMPONENTREPOSITORY___VAR_CI_)
+#define _IR_COMPONENTREPOSITORY___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ModuleDef_var
+// Inline operations for class IR::ComponentRepository_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ModuleDef_var::CORBA_ModuleDef_var (void) // default constructor
-  : ptr_ (CORBA_ModuleDef::_nil ())
+IR::ComponentRepository_var::ComponentRepository_var (void) // default constructor
+  : ptr_ (ComponentRepository::_nil ())
 {}
 
 ACE_INLINE
-CORBA_ModuleDef_var::CORBA_ModuleDef_var (CORBA_ModuleDef_ptr p)
+IR::ComponentRepository_var::ComponentRepository_var (ComponentRepository_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_ModuleDef_ptr 
-CORBA_ModuleDef_var::ptr (void) const
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ModuleDef_var::CORBA_ModuleDef_var (const CORBA_ModuleDef_var &p) // copy constructor
-  : ptr_ (CORBA_ModuleDef::_duplicate (p.ptr ()))
+IR::ComponentRepository_var::ComponentRepository_var (const ::IR::ComponentRepository_var &p) // copy constructor
+  : ptr_ (ComponentRepository::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_ModuleDef_var::~CORBA_ModuleDef_var (void) // destructor
+IR::ComponentRepository_var::~ComponentRepository_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_ModuleDef_var &
-CORBA_ModuleDef_var::operator= (CORBA_ModuleDef_ptr p)
+ACE_INLINE IR::ComponentRepository_var &
+IR::ComponentRepository_var::operator= (ComponentRepository_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ModuleDef_var &
-CORBA_ModuleDef_var::operator= (const CORBA_ModuleDef_var &p)
+ACE_INLINE IR::ComponentRepository_var &
+IR::ComponentRepository_var::operator= (const ::IR::ComponentRepository_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_ModuleDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::ComponentRepository::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ModuleDef_var::operator const CORBA_ModuleDef_ptr &() const // cast
+IR::ComponentRepository_var::operator const ::IR::ComponentRepository_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ModuleDef_var::operator CORBA_ModuleDef_ptr &() // cast 
+IR::ComponentRepository_var::operator ::IR::ComponentRepository_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDef_ptr 
-CORBA_ModuleDef_var::operator-> (void) const
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDef_ptr
-CORBA_ModuleDef_var::in (void) const
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDef_ptr &
-CORBA_ModuleDef_var::inout (void)
+ACE_INLINE ::IR::ComponentRepository_ptr &
+IR::ComponentRepository_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDef_ptr &
-CORBA_ModuleDef_var::out (void)
+ACE_INLINE ::IR::ComponentRepository_ptr &
+IR::ComponentRepository_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ModuleDef::_nil ();
+  this->ptr_ = ::IR::ComponentRepository::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDef_ptr 
-CORBA_ModuleDef_var::_retn (void)
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_ModuleDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_ModuleDef::_nil ();
+  ::IR::ComponentRepository_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ComponentRepository::_nil ();
   return val;
 }
 
@@ -4579,68 +7816,68 @@ CORBA_ModuleDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_MODULEDEF___OUT_CI_)
-#define _CORBA_MODULEDEF___OUT_CI_
+#if !defined (_IR_COMPONENTREPOSITORY___OUT_CI_)
+#define _IR_COMPONENTREPOSITORY___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ModuleDef_out
+// Inline operations for class IR::ComponentRepository_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ModuleDef_out::CORBA_ModuleDef_out (CORBA_ModuleDef_ptr &p)
+IR::ComponentRepository_out::ComponentRepository_out (ComponentRepository_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_ModuleDef::_nil ();
+  this->ptr_ = ::IR::ComponentRepository::_nil ();
 }
 
 ACE_INLINE
-CORBA_ModuleDef_out::CORBA_ModuleDef_out (CORBA_ModuleDef_var &p) // constructor from _var
+IR::ComponentRepository_out::ComponentRepository_out (ComponentRepository_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ModuleDef::_nil ();
+  this->ptr_ = ::IR::ComponentRepository::_nil ();
 }
 
 ACE_INLINE
-CORBA_ModuleDef_out::CORBA_ModuleDef_out (const CORBA_ModuleDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ModuleDef_out&,p).ptr_)
+IR::ComponentRepository_out::ComponentRepository_out (const ::IR::ComponentRepository_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ComponentRepository_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ModuleDef_out &
-CORBA_ModuleDef_out::operator= (const CORBA_ModuleDef_out &p)
+ACE_INLINE ::IR::ComponentRepository_out &
+IR::ComponentRepository_out::operator= (const ::IR::ComponentRepository_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ModuleDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ComponentRepository_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ModuleDef_out &
-CORBA_ModuleDef_out::operator= (const CORBA_ModuleDef_var &p)
+ACE_INLINE IR::ComponentRepository_out &
+IR::ComponentRepository_out::operator= (const ::IR::ComponentRepository_var &p)
 {
-  this->ptr_ = CORBA_ModuleDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::ComponentRepository::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_ModuleDef_out &
-CORBA_ModuleDef_out::operator= (CORBA_ModuleDef_ptr p)
+ACE_INLINE IR::ComponentRepository_out &
+IR::ComponentRepository_out::operator= (ComponentRepository_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ModuleDef_out::operator CORBA_ModuleDef_ptr &() // cast
+IR::ComponentRepository_out::operator ::IR::ComponentRepository_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDef_ptr &
-CORBA_ModuleDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::ComponentRepository_ptr &
+IR::ComponentRepository_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDef_ptr 
-CORBA_ModuleDef_out::operator-> (void)
+ACE_INLINE ::IR::ComponentRepository_ptr
+IR::ComponentRepository_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -4648,135 +7885,326 @@ CORBA_ModuleDef_out::operator-> (void)
 
 #endif /* end #if !defined */
 
+ACE_INLINE
+IR::ModuleDef::ModuleDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::ModuleDef::ModuleDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::ModuleDef::~ModuleDef (void) // destructor
+{}
+
+
+#if !defined (_IR_MODULEDEF___VAR_CI_)
+#define _IR_MODULEDEF___VAR_CI_
+
 // *************************************************************
-// Inline operations for class CORBA_ModuleDescription_var
+// Inline operations for class IR::ModuleDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ModuleDescription_var::CORBA_ModuleDescription_var (void) // default constructor
+IR::ModuleDef_var::ModuleDef_var (void) // default constructor
+  : ptr_ (ModuleDef::_nil ())
+{}
+
+ACE_INLINE
+IR::ModuleDef_var::ModuleDef_var (ModuleDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::ModuleDef_ptr
+IR::ModuleDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ModuleDef_var::ModuleDef_var (const ::IR::ModuleDef_var &p) // copy constructor
+  : ptr_ (ModuleDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ModuleDef_var::~ModuleDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ModuleDef_var &
+IR::ModuleDef_var::operator= (ModuleDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ModuleDef_var &
+IR::ModuleDef_var::operator= (const ::IR::ModuleDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::ModuleDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::ModuleDef_var::operator const ::IR::ModuleDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ModuleDef_var::operator ::IR::ModuleDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ModuleDef_ptr
+IR::ModuleDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ModuleDef_ptr
+IR::ModuleDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ModuleDef_ptr &
+IR::ModuleDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ModuleDef_ptr &
+IR::ModuleDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ModuleDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ModuleDef_ptr
+IR::ModuleDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::ModuleDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ModuleDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_MODULEDEF___OUT_CI_)
+#define _IR_MODULEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ModuleDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::ModuleDef_out::ModuleDef_out (ModuleDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::ModuleDef::_nil ();
+}
+
+ACE_INLINE
+IR::ModuleDef_out::ModuleDef_out (ModuleDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ModuleDef::_nil ();
+}
+
+ACE_INLINE
+IR::ModuleDef_out::ModuleDef_out (const ::IR::ModuleDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ModuleDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ModuleDef_out &
+IR::ModuleDef_out::operator= (const ::IR::ModuleDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (ModuleDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ModuleDef_out &
+IR::ModuleDef_out::operator= (const ::IR::ModuleDef_var &p)
+{
+  this->ptr_ = ::IR::ModuleDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ModuleDef_out &
+IR::ModuleDef_out::operator= (ModuleDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ModuleDef_out::operator ::IR::ModuleDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ModuleDef_ptr &
+IR::ModuleDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ModuleDef_ptr
+IR::ModuleDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class IR::ModuleDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::ModuleDescription_var::ModuleDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ModuleDescription_var::CORBA_ModuleDescription_var (CORBA_ModuleDescription *p)
+IR::ModuleDescription_var::ModuleDescription_var (ModuleDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ModuleDescription_var::CORBA_ModuleDescription_var (const CORBA_ModuleDescription_var &p) // copy constructor
+IR::ModuleDescription_var::ModuleDescription_var (const ::IR::ModuleDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ModuleDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ModuleDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ModuleDescription_var::~CORBA_ModuleDescription_var (void) // destructor
+IR::ModuleDescription_var::~ModuleDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDescription_var &
-CORBA_ModuleDescription_var::operator= (CORBA_ModuleDescription *p)
+ACE_INLINE IR::ModuleDescription_var &
+IR::ModuleDescription_var::operator= (ModuleDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ModuleDescription_var &
-CORBA_ModuleDescription_var::operator= (const CORBA_ModuleDescription_var &p)
+ACE_INLINE ::IR::ModuleDescription_var &
+IR::ModuleDescription_var::operator= (const ::IR::ModuleDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ModuleDescription (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ModuleDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ModuleDescription *
-CORBA_ModuleDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::ModuleDescription *
+IR::ModuleDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDescription *
-CORBA_ModuleDescription_var::operator-> (void)
+ACE_INLINE ::IR::ModuleDescription *
+IR::ModuleDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ModuleDescription_var::operator const CORBA_ModuleDescription &() const // cast
+ACE_INLINE
+IR::ModuleDescription_var::operator const ::IR::ModuleDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ModuleDescription_var::operator CORBA_ModuleDescription &() // cast 
+ACE_INLINE
+IR::ModuleDescription_var::operator ::IR::ModuleDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ModuleDescription_var::operator CORBA_ModuleDescription &() const// cast 
+ACE_INLINE
+IR::ModuleDescription_var::operator ::IR::ModuleDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_ModuleDescription &
-CORBA_ModuleDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::ModuleDescription_var::operator ::IR::ModuleDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::ModuleDescription &
+IR::ModuleDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDescription &
-CORBA_ModuleDescription_var::inout (void)
+ACE_INLINE ::IR::ModuleDescription &
+IR::ModuleDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ModuleDescription *&
-CORBA_ModuleDescription_var::out (void)
+ACE_INLINE ::IR::ModuleDescription *&
+IR::ModuleDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDescription *
-CORBA_ModuleDescription_var::_retn (void)
+ACE_INLINE ::IR::ModuleDescription *
+IR::ModuleDescription_var::_retn (void)
 {
-  CORBA_ModuleDescription *tmp = this->ptr_;
+  ::IR::ModuleDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ModuleDescription *
-CORBA_ModuleDescription_var::ptr (void) const
+ACE_INLINE ::IR::ModuleDescription *
+IR::ModuleDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ModuleDescription_out
+// Inline operations for class IR::ModuleDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ModuleDescription_out::CORBA_ModuleDescription_out (CORBA_ModuleDescription *&p)
+IR::ModuleDescription_out::ModuleDescription_out (::IR::ModuleDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ModuleDescription_out::CORBA_ModuleDescription_out (CORBA_ModuleDescription_var &p) // constructor from _var
+IR::ModuleDescription_out::ModuleDescription_out (ModuleDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -4784,153 +8212,153 @@ CORBA_ModuleDescription_out::CORBA_ModuleDescription_out (CORBA_ModuleDescriptio
 }
 
 ACE_INLINE
-CORBA_ModuleDescription_out::CORBA_ModuleDescription_out (const CORBA_ModuleDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ModuleDescription_out&,p).ptr_)
+IR::ModuleDescription_out::ModuleDescription_out (const ::IR::ModuleDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ModuleDescription_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ModuleDescription_out &
-CORBA_ModuleDescription_out::operator= (const CORBA_ModuleDescription_out &p)
+ACE_INLINE IR::ModuleDescription_out &
+IR::ModuleDescription_out::operator= (const ::IR::ModuleDescription_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ModuleDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ModuleDescription_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ModuleDescription_out &
-CORBA_ModuleDescription_out::operator= (CORBA_ModuleDescription *p)
+ACE_INLINE IR::ModuleDescription_out &
+IR::ModuleDescription_out::operator= (ModuleDescription *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ModuleDescription_out::operator CORBA_ModuleDescription *&() // cast
+IR::ModuleDescription_out::operator ::IR::ModuleDescription *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDescription *&
-CORBA_ModuleDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::ModuleDescription *&
+IR::ModuleDescription_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ModuleDescription *
-CORBA_ModuleDescription_out::operator-> (void)
+ACE_INLINE ::IR::ModuleDescription *
+IR::ModuleDescription_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ConstantDef::CORBA_ConstantDef (void) // default constructor
+IR::ConstantDef::ConstantDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_ConstantDef::CORBA_ConstantDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::ConstantDef::ConstantDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_ConstantDef::~CORBA_ConstantDef (void) // destructor
+IR::ConstantDef::~ConstantDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_CONSTANTDEF___VAR_CI_)
-#define _CORBA_CONSTANTDEF___VAR_CI_
+#if !defined (_IR_CONSTANTDEF___VAR_CI_)
+#define _IR_CONSTANTDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ConstantDef_var
+// Inline operations for class IR::ConstantDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ConstantDef_var::CORBA_ConstantDef_var (void) // default constructor
-  : ptr_ (CORBA_ConstantDef::_nil ())
+IR::ConstantDef_var::ConstantDef_var (void) // default constructor
+  : ptr_ (ConstantDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_ConstantDef_var::CORBA_ConstantDef_var (CORBA_ConstantDef_ptr p)
+IR::ConstantDef_var::ConstantDef_var (ConstantDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_ConstantDef_ptr 
-CORBA_ConstantDef_var::ptr (void) const
+ACE_INLINE ::IR::ConstantDef_ptr
+IR::ConstantDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ConstantDef_var::CORBA_ConstantDef_var (const CORBA_ConstantDef_var &p) // copy constructor
-  : ptr_ (CORBA_ConstantDef::_duplicate (p.ptr ()))
+IR::ConstantDef_var::ConstantDef_var (const ::IR::ConstantDef_var &p) // copy constructor
+  : ptr_ (ConstantDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_ConstantDef_var::~CORBA_ConstantDef_var (void) // destructor
+IR::ConstantDef_var::~ConstantDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_ConstantDef_var &
-CORBA_ConstantDef_var::operator= (CORBA_ConstantDef_ptr p)
+ACE_INLINE IR::ConstantDef_var &
+IR::ConstantDef_var::operator= (ConstantDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ConstantDef_var &
-CORBA_ConstantDef_var::operator= (const CORBA_ConstantDef_var &p)
+ACE_INLINE IR::ConstantDef_var &
+IR::ConstantDef_var::operator= (const ::IR::ConstantDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_ConstantDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::ConstantDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ConstantDef_var::operator const CORBA_ConstantDef_ptr &() const // cast
+IR::ConstantDef_var::operator const ::IR::ConstantDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ConstantDef_var::operator CORBA_ConstantDef_ptr &() // cast 
+IR::ConstantDef_var::operator ::IR::ConstantDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDef_ptr 
-CORBA_ConstantDef_var::operator-> (void) const
+ACE_INLINE ::IR::ConstantDef_ptr
+IR::ConstantDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDef_ptr
-CORBA_ConstantDef_var::in (void) const
+ACE_INLINE ::IR::ConstantDef_ptr
+IR::ConstantDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDef_ptr &
-CORBA_ConstantDef_var::inout (void)
+ACE_INLINE ::IR::ConstantDef_ptr &
+IR::ConstantDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDef_ptr &
-CORBA_ConstantDef_var::out (void)
+ACE_INLINE ::IR::ConstantDef_ptr &
+IR::ConstantDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ConstantDef::_nil ();
+  this->ptr_ = ::IR::ConstantDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDef_ptr 
-CORBA_ConstantDef_var::_retn (void)
+ACE_INLINE ::IR::ConstantDef_ptr
+IR::ConstantDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_ConstantDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_ConstantDef::_nil ();
+  ::IR::ConstantDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ConstantDef::_nil ();
   return val;
 }
 
@@ -4938,68 +8366,68 @@ CORBA_ConstantDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONSTANTDEF___OUT_CI_)
-#define _CORBA_CONSTANTDEF___OUT_CI_
+#if !defined (_IR_CONSTANTDEF___OUT_CI_)
+#define _IR_CONSTANTDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ConstantDef_out
+// Inline operations for class IR::ConstantDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ConstantDef_out::CORBA_ConstantDef_out (CORBA_ConstantDef_ptr &p)
+IR::ConstantDef_out::ConstantDef_out (ConstantDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_ConstantDef::_nil ();
+  this->ptr_ = ::IR::ConstantDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_ConstantDef_out::CORBA_ConstantDef_out (CORBA_ConstantDef_var &p) // constructor from _var
+IR::ConstantDef_out::ConstantDef_out (ConstantDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ConstantDef::_nil ();
+  this->ptr_ = ::IR::ConstantDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_ConstantDef_out::CORBA_ConstantDef_out (const CORBA_ConstantDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ConstantDef_out&,p).ptr_)
+IR::ConstantDef_out::ConstantDef_out (const ::IR::ConstantDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ConstantDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ConstantDef_out &
-CORBA_ConstantDef_out::operator= (const CORBA_ConstantDef_out &p)
+ACE_INLINE ::IR::ConstantDef_out &
+IR::ConstantDef_out::operator= (const ::IR::ConstantDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ConstantDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ConstantDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ConstantDef_out &
-CORBA_ConstantDef_out::operator= (const CORBA_ConstantDef_var &p)
+ACE_INLINE IR::ConstantDef_out &
+IR::ConstantDef_out::operator= (const ::IR::ConstantDef_var &p)
 {
-  this->ptr_ = CORBA_ConstantDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::ConstantDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_ConstantDef_out &
-CORBA_ConstantDef_out::operator= (CORBA_ConstantDef_ptr p)
+ACE_INLINE IR::ConstantDef_out &
+IR::ConstantDef_out::operator= (ConstantDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ConstantDef_out::operator CORBA_ConstantDef_ptr &() // cast
+IR::ConstantDef_out::operator ::IR::ConstantDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDef_ptr &
-CORBA_ConstantDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::ConstantDef_ptr &
+IR::ConstantDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDef_ptr 
-CORBA_ConstantDef_out::operator-> (void)
+ACE_INLINE ::IR::ConstantDef_ptr
+IR::ConstantDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -5008,134 +8436,138 @@ CORBA_ConstantDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA_ConstantDescription_var
+// Inline operations for class IR::ConstantDescription_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ConstantDescription_var::CORBA_ConstantDescription_var (void) // default constructor
+IR::ConstantDescription_var::ConstantDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ConstantDescription_var::CORBA_ConstantDescription_var (CORBA_ConstantDescription *p)
+IR::ConstantDescription_var::ConstantDescription_var (ConstantDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ConstantDescription_var::CORBA_ConstantDescription_var (const CORBA_ConstantDescription_var &p) // copy constructor
+IR::ConstantDescription_var::ConstantDescription_var (const ::IR::ConstantDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ConstantDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ConstantDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ConstantDescription_var::~CORBA_ConstantDescription_var (void) // destructor
+IR::ConstantDescription_var::~ConstantDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDescription_var &
-CORBA_ConstantDescription_var::operator= (CORBA_ConstantDescription *p)
+ACE_INLINE IR::ConstantDescription_var &
+IR::ConstantDescription_var::operator= (ConstantDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ConstantDescription_var &
-CORBA_ConstantDescription_var::operator= (const CORBA_ConstantDescription_var &p)
+ACE_INLINE ::IR::ConstantDescription_var &
+IR::ConstantDescription_var::operator= (const ::IR::ConstantDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ConstantDescription (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ConstantDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ConstantDescription *
-CORBA_ConstantDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::ConstantDescription *
+IR::ConstantDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDescription *
-CORBA_ConstantDescription_var::operator-> (void)
+ACE_INLINE ::IR::ConstantDescription *
+IR::ConstantDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ConstantDescription_var::operator const CORBA_ConstantDescription &() const // cast
+ACE_INLINE
+IR::ConstantDescription_var::operator const ::IR::ConstantDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ConstantDescription_var::operator CORBA_ConstantDescription &() // cast 
+ACE_INLINE
+IR::ConstantDescription_var::operator ::IR::ConstantDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ConstantDescription_var::operator CORBA_ConstantDescription &() const// cast 
+ACE_INLINE
+IR::ConstantDescription_var::operator ::IR::ConstantDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_ConstantDescription &
-CORBA_ConstantDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::ConstantDescription_var::operator ::IR::ConstantDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::ConstantDescription &
+IR::ConstantDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDescription &
-CORBA_ConstantDescription_var::inout (void)
+ACE_INLINE ::IR::ConstantDescription &
+IR::ConstantDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ConstantDescription *&
-CORBA_ConstantDescription_var::out (void)
+ACE_INLINE ::IR::ConstantDescription *&
+IR::ConstantDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDescription *
-CORBA_ConstantDescription_var::_retn (void)
+ACE_INLINE ::IR::ConstantDescription *
+IR::ConstantDescription_var::_retn (void)
 {
-  CORBA_ConstantDescription *tmp = this->ptr_;
+  ::IR::ConstantDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ConstantDescription *
-CORBA_ConstantDescription_var::ptr (void) const
+ACE_INLINE ::IR::ConstantDescription *
+IR::ConstantDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ConstantDescription_out
+// Inline operations for class IR::ConstantDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ConstantDescription_out::CORBA_ConstantDescription_out (CORBA_ConstantDescription *&p)
+IR::ConstantDescription_out::ConstantDescription_out (::IR::ConstantDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ConstantDescription_out::CORBA_ConstantDescription_out (CORBA_ConstantDescription_var &p) // constructor from _var
+IR::ConstantDescription_out::ConstantDescription_out (ConstantDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -5143,153 +8575,153 @@ CORBA_ConstantDescription_out::CORBA_ConstantDescription_out (CORBA_ConstantDesc
 }
 
 ACE_INLINE
-CORBA_ConstantDescription_out::CORBA_ConstantDescription_out (const CORBA_ConstantDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ConstantDescription_out&,p).ptr_)
+IR::ConstantDescription_out::ConstantDescription_out (const ::IR::ConstantDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ConstantDescription_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ConstantDescription_out &
-CORBA_ConstantDescription_out::operator= (const CORBA_ConstantDescription_out &p)
+ACE_INLINE IR::ConstantDescription_out &
+IR::ConstantDescription_out::operator= (const ::IR::ConstantDescription_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ConstantDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ConstantDescription_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ConstantDescription_out &
-CORBA_ConstantDescription_out::operator= (CORBA_ConstantDescription *p)
+ACE_INLINE IR::ConstantDescription_out &
+IR::ConstantDescription_out::operator= (ConstantDescription *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ConstantDescription_out::operator CORBA_ConstantDescription *&() // cast
+IR::ConstantDescription_out::operator ::IR::ConstantDescription *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDescription *&
-CORBA_ConstantDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::ConstantDescription *&
+IR::ConstantDescription_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ConstantDescription *
-CORBA_ConstantDescription_out::operator-> (void)
+ACE_INLINE ::IR::ConstantDescription *
+IR::ConstantDescription_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_TypedefDef::CORBA_TypedefDef (void) // default constructor
+IR::TypedefDef::TypedefDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_TypedefDef::CORBA_TypedefDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::TypedefDef::TypedefDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_TypedefDef::~CORBA_TypedefDef (void) // destructor
+IR::TypedefDef::~TypedefDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_TYPEDEFDEF___VAR_CI_)
-#define _CORBA_TYPEDEFDEF___VAR_CI_
+#if !defined (_IR_TYPEDEFDEF___VAR_CI_)
+#define _IR_TYPEDEFDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_TypedefDef_var
+// Inline operations for class IR::TypedefDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_TypedefDef_var::CORBA_TypedefDef_var (void) // default constructor
-  : ptr_ (CORBA_TypedefDef::_nil ())
+IR::TypedefDef_var::TypedefDef_var (void) // default constructor
+  : ptr_ (TypedefDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_TypedefDef_var::CORBA_TypedefDef_var (CORBA_TypedefDef_ptr p)
+IR::TypedefDef_var::TypedefDef_var (TypedefDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_TypedefDef_ptr 
-CORBA_TypedefDef_var::ptr (void) const
+ACE_INLINE ::IR::TypedefDef_ptr
+IR::TypedefDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_TypedefDef_var::CORBA_TypedefDef_var (const CORBA_TypedefDef_var &p) // copy constructor
-  : ptr_ (CORBA_TypedefDef::_duplicate (p.ptr ()))
+IR::TypedefDef_var::TypedefDef_var (const ::IR::TypedefDef_var &p) // copy constructor
+  : ptr_ (TypedefDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_TypedefDef_var::~CORBA_TypedefDef_var (void) // destructor
+IR::TypedefDef_var::~TypedefDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_TypedefDef_var &
-CORBA_TypedefDef_var::operator= (CORBA_TypedefDef_ptr p)
+ACE_INLINE IR::TypedefDef_var &
+IR::TypedefDef_var::operator= (TypedefDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_TypedefDef_var &
-CORBA_TypedefDef_var::operator= (const CORBA_TypedefDef_var &p)
+ACE_INLINE IR::TypedefDef_var &
+IR::TypedefDef_var::operator= (const ::IR::TypedefDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_TypedefDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::TypedefDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_TypedefDef_var::operator const CORBA_TypedefDef_ptr &() const // cast
+IR::TypedefDef_var::operator const ::IR::TypedefDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_TypedefDef_var::operator CORBA_TypedefDef_ptr &() // cast 
+IR::TypedefDef_var::operator ::IR::TypedefDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypedefDef_ptr 
-CORBA_TypedefDef_var::operator-> (void) const
+ACE_INLINE ::IR::TypedefDef_ptr
+IR::TypedefDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypedefDef_ptr
-CORBA_TypedefDef_var::in (void) const
+ACE_INLINE ::IR::TypedefDef_ptr
+IR::TypedefDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypedefDef_ptr &
-CORBA_TypedefDef_var::inout (void)
+ACE_INLINE ::IR::TypedefDef_ptr &
+IR::TypedefDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypedefDef_ptr &
-CORBA_TypedefDef_var::out (void)
+ACE_INLINE ::IR::TypedefDef_ptr &
+IR::TypedefDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_TypedefDef::_nil ();
+  this->ptr_ = ::IR::TypedefDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypedefDef_ptr 
-CORBA_TypedefDef_var::_retn (void)
+ACE_INLINE ::IR::TypedefDef_ptr
+IR::TypedefDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_TypedefDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_TypedefDef::_nil ();
+  ::IR::TypedefDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::TypedefDef::_nil ();
   return val;
 }
 
@@ -5297,68 +8729,68 @@ CORBA_TypedefDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_TYPEDEFDEF___OUT_CI_)
-#define _CORBA_TYPEDEFDEF___OUT_CI_
+#if !defined (_IR_TYPEDEFDEF___OUT_CI_)
+#define _IR_TYPEDEFDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_TypedefDef_out
+// Inline operations for class IR::TypedefDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_TypedefDef_out::CORBA_TypedefDef_out (CORBA_TypedefDef_ptr &p)
+IR::TypedefDef_out::TypedefDef_out (TypedefDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_TypedefDef::_nil ();
+  this->ptr_ = ::IR::TypedefDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_TypedefDef_out::CORBA_TypedefDef_out (CORBA_TypedefDef_var &p) // constructor from _var
+IR::TypedefDef_out::TypedefDef_out (TypedefDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_TypedefDef::_nil ();
+  this->ptr_ = ::IR::TypedefDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_TypedefDef_out::CORBA_TypedefDef_out (const CORBA_TypedefDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_TypedefDef_out&,p).ptr_)
+IR::TypedefDef_out::TypedefDef_out (const ::IR::TypedefDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (TypedefDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_TypedefDef_out &
-CORBA_TypedefDef_out::operator= (const CORBA_TypedefDef_out &p)
+ACE_INLINE ::IR::TypedefDef_out &
+IR::TypedefDef_out::operator= (const ::IR::TypedefDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_TypedefDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (TypedefDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_TypedefDef_out &
-CORBA_TypedefDef_out::operator= (const CORBA_TypedefDef_var &p)
+ACE_INLINE IR::TypedefDef_out &
+IR::TypedefDef_out::operator= (const ::IR::TypedefDef_var &p)
 {
-  this->ptr_ = CORBA_TypedefDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::TypedefDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_TypedefDef_out &
-CORBA_TypedefDef_out::operator= (CORBA_TypedefDef_ptr p)
+ACE_INLINE IR::TypedefDef_out &
+IR::TypedefDef_out::operator= (TypedefDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_TypedefDef_out::operator CORBA_TypedefDef_ptr &() // cast
+IR::TypedefDef_out::operator ::IR::TypedefDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypedefDef_ptr &
-CORBA_TypedefDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::TypedefDef_ptr &
+IR::TypedefDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypedefDef_ptr 
-CORBA_TypedefDef_out::operator-> (void)
+ACE_INLINE ::IR::TypedefDef_ptr
+IR::TypedefDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -5367,134 +8799,138 @@ CORBA_TypedefDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA_TypeDescription_var
+// Inline operations for class IR::TypeDescription_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_TypeDescription_var::CORBA_TypeDescription_var (void) // default constructor
+IR::TypeDescription_var::TypeDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_TypeDescription_var::CORBA_TypeDescription_var (CORBA_TypeDescription *p)
+IR::TypeDescription_var::TypeDescription_var (TypeDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_TypeDescription_var::CORBA_TypeDescription_var (const CORBA_TypeDescription_var &p) // copy constructor
+IR::TypeDescription_var::TypeDescription_var (const ::IR::TypeDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_TypeDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::TypeDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_TypeDescription_var::~CORBA_TypeDescription_var (void) // destructor
+IR::TypeDescription_var::~TypeDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeDescription_var &
-CORBA_TypeDescription_var::operator= (CORBA_TypeDescription *p)
+ACE_INLINE IR::TypeDescription_var &
+IR::TypeDescription_var::operator= (TypeDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_TypeDescription_var &
-CORBA_TypeDescription_var::operator= (const CORBA_TypeDescription_var &p)
+ACE_INLINE ::IR::TypeDescription_var &
+IR::TypeDescription_var::operator= (const ::IR::TypeDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_TypeDescription (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::TypeDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_TypeDescription *
-CORBA_TypeDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::TypeDescription *
+IR::TypeDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeDescription *
-CORBA_TypeDescription_var::operator-> (void)
+ACE_INLINE ::IR::TypeDescription *
+IR::TypeDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_TypeDescription_var::operator const CORBA_TypeDescription &() const // cast
+ACE_INLINE
+IR::TypeDescription_var::operator const ::IR::TypeDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_TypeDescription_var::operator CORBA_TypeDescription &() // cast 
+ACE_INLINE
+IR::TypeDescription_var::operator ::IR::TypeDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_TypeDescription_var::operator CORBA_TypeDescription &() const// cast 
+ACE_INLINE
+IR::TypeDescription_var::operator ::IR::TypeDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_TypeDescription &
-CORBA_TypeDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::TypeDescription_var::operator ::IR::TypeDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::TypeDescription &
+IR::TypeDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeDescription &
-CORBA_TypeDescription_var::inout (void)
+ACE_INLINE ::IR::TypeDescription &
+IR::TypeDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_TypeDescription *&
-CORBA_TypeDescription_var::out (void)
+ACE_INLINE ::IR::TypeDescription *&
+IR::TypeDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeDescription *
-CORBA_TypeDescription_var::_retn (void)
+ACE_INLINE ::IR::TypeDescription *
+IR::TypeDescription_var::_retn (void)
 {
-  CORBA_TypeDescription *tmp = this->ptr_;
+  ::IR::TypeDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_TypeDescription *
-CORBA_TypeDescription_var::ptr (void) const
+ACE_INLINE ::IR::TypeDescription *
+IR::TypeDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_TypeDescription_out
+// Inline operations for class IR::TypeDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_TypeDescription_out::CORBA_TypeDescription_out (CORBA_TypeDescription *&p)
+IR::TypeDescription_out::TypeDescription_out (::IR::TypeDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_TypeDescription_out::CORBA_TypeDescription_out (CORBA_TypeDescription_var &p) // constructor from _var
+IR::TypeDescription_out::TypeDescription_out (TypeDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -5502,153 +8938,340 @@ CORBA_TypeDescription_out::CORBA_TypeDescription_out (CORBA_TypeDescription_var
 }
 
 ACE_INLINE
-CORBA_TypeDescription_out::CORBA_TypeDescription_out (const CORBA_TypeDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_TypeDescription_out&,p).ptr_)
+IR::TypeDescription_out::TypeDescription_out (const ::IR::TypeDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (TypeDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::TypeDescription_out &
+IR::TypeDescription_out::operator= (const ::IR::TypeDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (TypeDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::TypeDescription_out &
+IR::TypeDescription_out::operator= (TypeDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::TypeDescription_out::operator ::IR::TypeDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::TypeDescription *&
+IR::TypeDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::TypeDescription *
+IR::TypeDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::StructDef::StructDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::StructDef::StructDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::StructDef::~StructDef (void) // destructor
+{}
+
+
+#if !defined (_IR_STRUCTDEF___VAR_CI_)
+#define _IR_STRUCTDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::StructDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::StructDef_var::StructDef_var (void) // default constructor
+  : ptr_ (StructDef::_nil ())
+{}
+
+ACE_INLINE
+IR::StructDef_var::StructDef_var (StructDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::StructDef_ptr
+IR::StructDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::StructDef_var::StructDef_var (const ::IR::StructDef_var &p) // copy constructor
+  : ptr_ (StructDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::StructDef_var::~StructDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::StructDef_var &
+IR::StructDef_var::operator= (StructDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::StructDef_var &
+IR::StructDef_var::operator= (const ::IR::StructDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::StructDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::StructDef_var::operator const ::IR::StructDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::StructDef_var::operator ::IR::StructDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::StructDef_ptr
+IR::StructDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::StructDef_ptr
+IR::StructDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::StructDef_ptr &
+IR::StructDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::StructDef_ptr &
+IR::StructDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::StructDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::StructDef_ptr
+IR::StructDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::StructDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::StructDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_STRUCTDEF___OUT_CI_)
+#define _IR_STRUCTDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::StructDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::StructDef_out::StructDef_out (StructDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::StructDef::_nil ();
+}
+
+ACE_INLINE
+IR::StructDef_out::StructDef_out (StructDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::StructDef::_nil ();
+}
+
+ACE_INLINE
+IR::StructDef_out::StructDef_out (const ::IR::StructDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (StructDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_TypeDescription_out &
-CORBA_TypeDescription_out::operator= (const CORBA_TypeDescription_out &p)
+ACE_INLINE ::IR::StructDef_out &
+IR::StructDef_out::operator= (const ::IR::StructDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_TypeDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (StructDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_TypeDescription_out &
-CORBA_TypeDescription_out::operator= (CORBA_TypeDescription *p)
+ACE_INLINE IR::StructDef_out &
+IR::StructDef_out::operator= (const ::IR::StructDef_var &p)
+{
+  this->ptr_ = ::IR::StructDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::StructDef_out &
+IR::StructDef_out::operator= (StructDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_TypeDescription_out::operator CORBA_TypeDescription *&() // cast
+IR::StructDef_out::operator ::IR::StructDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeDescription *&
-CORBA_TypeDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::StructDef_ptr &
+IR::StructDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_TypeDescription *
-CORBA_TypeDescription_out::operator-> (void)
+ACE_INLINE ::IR::StructDef_ptr
+IR::StructDef_out::operator-> (void)
 {
   return this->ptr_;
 }
 
+
+#endif /* end #if !defined */
+
 ACE_INLINE
-CORBA_StructDef::CORBA_StructDef (void) // default constructor
+IR::UnionDef::UnionDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_StructDef::CORBA_StructDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::UnionDef::UnionDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_StructDef::~CORBA_StructDef (void) // destructor
+IR::UnionDef::~UnionDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_STRUCTDEF___VAR_CI_)
-#define _CORBA_STRUCTDEF___VAR_CI_
+#if !defined (_IR_UNIONDEF___VAR_CI_)
+#define _IR_UNIONDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_StructDef_var
+// Inline operations for class IR::UnionDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_StructDef_var::CORBA_StructDef_var (void) // default constructor
-  : ptr_ (CORBA_StructDef::_nil ())
+IR::UnionDef_var::UnionDef_var (void) // default constructor
+  : ptr_ (UnionDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_StructDef_var::CORBA_StructDef_var (CORBA_StructDef_ptr p)
+IR::UnionDef_var::UnionDef_var (UnionDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_StructDef_ptr 
-CORBA_StructDef_var::ptr (void) const
+ACE_INLINE ::IR::UnionDef_ptr
+IR::UnionDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_StructDef_var::CORBA_StructDef_var (const CORBA_StructDef_var &p) // copy constructor
-  : ptr_ (CORBA_StructDef::_duplicate (p.ptr ()))
+IR::UnionDef_var::UnionDef_var (const ::IR::UnionDef_var &p) // copy constructor
+  : ptr_ (UnionDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_StructDef_var::~CORBA_StructDef_var (void) // destructor
+IR::UnionDef_var::~UnionDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_StructDef_var &
-CORBA_StructDef_var::operator= (CORBA_StructDef_ptr p)
+ACE_INLINE IR::UnionDef_var &
+IR::UnionDef_var::operator= (UnionDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_StructDef_var &
-CORBA_StructDef_var::operator= (const CORBA_StructDef_var &p)
+ACE_INLINE IR::UnionDef_var &
+IR::UnionDef_var::operator= (const ::IR::UnionDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_StructDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::UnionDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_StructDef_var::operator const CORBA_StructDef_ptr &() const // cast
+IR::UnionDef_var::operator const ::IR::UnionDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StructDef_var::operator CORBA_StructDef_ptr &() // cast 
+IR::UnionDef_var::operator ::IR::UnionDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructDef_ptr 
-CORBA_StructDef_var::operator-> (void) const
+ACE_INLINE ::IR::UnionDef_ptr
+IR::UnionDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructDef_ptr
-CORBA_StructDef_var::in (void) const
+ACE_INLINE ::IR::UnionDef_ptr
+IR::UnionDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructDef_ptr &
-CORBA_StructDef_var::inout (void)
+ACE_INLINE ::IR::UnionDef_ptr &
+IR::UnionDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructDef_ptr &
-CORBA_StructDef_var::out (void)
+ACE_INLINE ::IR::UnionDef_ptr &
+IR::UnionDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_StructDef::_nil ();
+  this->ptr_ = ::IR::UnionDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructDef_ptr 
-CORBA_StructDef_var::_retn (void)
+ACE_INLINE ::IR::UnionDef_ptr
+IR::UnionDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_StructDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_StructDef::_nil ();
+  ::IR::UnionDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::UnionDef::_nil ();
   return val;
 }
 
@@ -5656,68 +9279,68 @@ CORBA_StructDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRUCTDEF___OUT_CI_)
-#define _CORBA_STRUCTDEF___OUT_CI_
+#if !defined (_IR_UNIONDEF___OUT_CI_)
+#define _IR_UNIONDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_StructDef_out
+// Inline operations for class IR::UnionDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_StructDef_out::CORBA_StructDef_out (CORBA_StructDef_ptr &p)
+IR::UnionDef_out::UnionDef_out (UnionDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_StructDef::_nil ();
+  this->ptr_ = ::IR::UnionDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_StructDef_out::CORBA_StructDef_out (CORBA_StructDef_var &p) // constructor from _var
+IR::UnionDef_out::UnionDef_out (UnionDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_StructDef::_nil ();
+  this->ptr_ = ::IR::UnionDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_StructDef_out::CORBA_StructDef_out (const CORBA_StructDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_StructDef_out&,p).ptr_)
+IR::UnionDef_out::UnionDef_out (const ::IR::UnionDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UnionDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_StructDef_out &
-CORBA_StructDef_out::operator= (const CORBA_StructDef_out &p)
+ACE_INLINE ::IR::UnionDef_out &
+IR::UnionDef_out::operator= (const ::IR::UnionDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_StructDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (UnionDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_StructDef_out &
-CORBA_StructDef_out::operator= (const CORBA_StructDef_var &p)
+ACE_INLINE IR::UnionDef_out &
+IR::UnionDef_out::operator= (const ::IR::UnionDef_var &p)
 {
-  this->ptr_ = CORBA_StructDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::UnionDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_StructDef_out &
-CORBA_StructDef_out::operator= (CORBA_StructDef_ptr p)
+ACE_INLINE IR::UnionDef_out &
+IR::UnionDef_out::operator= (UnionDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_StructDef_out::operator CORBA_StructDef_ptr &() // cast
+IR::UnionDef_out::operator ::IR::UnionDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructDef_ptr &
-CORBA_StructDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::UnionDef_ptr &
+IR::UnionDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StructDef_ptr 
-CORBA_StructDef_out::operator-> (void)
+ACE_INLINE ::IR::UnionDef_ptr
+IR::UnionDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -5726,116 +9349,116 @@ CORBA_StructDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_UnionDef::CORBA_UnionDef (void) // default constructor
+IR::EnumDef::EnumDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_UnionDef::CORBA_UnionDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::EnumDef::EnumDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_UnionDef::~CORBA_UnionDef (void) // destructor
+IR::EnumDef::~EnumDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_UNIONDEF___VAR_CI_)
-#define _CORBA_UNIONDEF___VAR_CI_
+#if !defined (_IR_ENUMDEF___VAR_CI_)
+#define _IR_ENUMDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_UnionDef_var
+// Inline operations for class IR::EnumDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_UnionDef_var::CORBA_UnionDef_var (void) // default constructor
-  : ptr_ (CORBA_UnionDef::_nil ())
+IR::EnumDef_var::EnumDef_var (void) // default constructor
+  : ptr_ (EnumDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_UnionDef_var::CORBA_UnionDef_var (CORBA_UnionDef_ptr p)
+IR::EnumDef_var::EnumDef_var (EnumDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_UnionDef_ptr 
-CORBA_UnionDef_var::ptr (void) const
+ACE_INLINE ::IR::EnumDef_ptr
+IR::EnumDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_UnionDef_var::CORBA_UnionDef_var (const CORBA_UnionDef_var &p) // copy constructor
-  : ptr_ (CORBA_UnionDef::_duplicate (p.ptr ()))
+IR::EnumDef_var::EnumDef_var (const ::IR::EnumDef_var &p) // copy constructor
+  : ptr_ (EnumDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_UnionDef_var::~CORBA_UnionDef_var (void) // destructor
+IR::EnumDef_var::~EnumDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_UnionDef_var &
-CORBA_UnionDef_var::operator= (CORBA_UnionDef_ptr p)
+ACE_INLINE IR::EnumDef_var &
+IR::EnumDef_var::operator= (EnumDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_UnionDef_var &
-CORBA_UnionDef_var::operator= (const CORBA_UnionDef_var &p)
+ACE_INLINE IR::EnumDef_var &
+IR::EnumDef_var::operator= (const ::IR::EnumDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_UnionDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::EnumDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_UnionDef_var::operator const CORBA_UnionDef_ptr &() const // cast
+IR::EnumDef_var::operator const ::IR::EnumDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_UnionDef_var::operator CORBA_UnionDef_ptr &() // cast 
+IR::EnumDef_var::operator ::IR::EnumDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionDef_ptr 
-CORBA_UnionDef_var::operator-> (void) const
+ACE_INLINE ::IR::EnumDef_ptr
+IR::EnumDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionDef_ptr
-CORBA_UnionDef_var::in (void) const
+ACE_INLINE ::IR::EnumDef_ptr
+IR::EnumDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionDef_ptr &
-CORBA_UnionDef_var::inout (void)
+ACE_INLINE ::IR::EnumDef_ptr &
+IR::EnumDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionDef_ptr &
-CORBA_UnionDef_var::out (void)
+ACE_INLINE ::IR::EnumDef_ptr &
+IR::EnumDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_UnionDef::_nil ();
+  this->ptr_ = ::IR::EnumDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionDef_ptr 
-CORBA_UnionDef_var::_retn (void)
+ACE_INLINE ::IR::EnumDef_ptr
+IR::EnumDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_UnionDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_UnionDef::_nil ();
+  ::IR::EnumDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::EnumDef::_nil ();
   return val;
 }
 
@@ -5843,68 +9466,68 @@ CORBA_UnionDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_UNIONDEF___OUT_CI_)
-#define _CORBA_UNIONDEF___OUT_CI_
+#if !defined (_IR_ENUMDEF___OUT_CI_)
+#define _IR_ENUMDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_UnionDef_out
+// Inline operations for class IR::EnumDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_UnionDef_out::CORBA_UnionDef_out (CORBA_UnionDef_ptr &p)
+IR::EnumDef_out::EnumDef_out (EnumDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_UnionDef::_nil ();
+  this->ptr_ = ::IR::EnumDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_UnionDef_out::CORBA_UnionDef_out (CORBA_UnionDef_var &p) // constructor from _var
+IR::EnumDef_out::EnumDef_out (EnumDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_UnionDef::_nil ();
+  this->ptr_ = ::IR::EnumDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_UnionDef_out::CORBA_UnionDef_out (const CORBA_UnionDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_UnionDef_out&,p).ptr_)
+IR::EnumDef_out::EnumDef_out (const ::IR::EnumDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (EnumDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_UnionDef_out &
-CORBA_UnionDef_out::operator= (const CORBA_UnionDef_out &p)
+ACE_INLINE ::IR::EnumDef_out &
+IR::EnumDef_out::operator= (const ::IR::EnumDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_UnionDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (EnumDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_UnionDef_out &
-CORBA_UnionDef_out::operator= (const CORBA_UnionDef_var &p)
+ACE_INLINE IR::EnumDef_out &
+IR::EnumDef_out::operator= (const ::IR::EnumDef_var &p)
 {
-  this->ptr_ = CORBA_UnionDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::EnumDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_UnionDef_out &
-CORBA_UnionDef_out::operator= (CORBA_UnionDef_ptr p)
+ACE_INLINE IR::EnumDef_out &
+IR::EnumDef_out::operator= (EnumDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_UnionDef_out::operator CORBA_UnionDef_ptr &() // cast
+IR::EnumDef_out::operator ::IR::EnumDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionDef_ptr &
-CORBA_UnionDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::EnumDef_ptr &
+IR::EnumDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_UnionDef_ptr 
-CORBA_UnionDef_out::operator-> (void)
+ACE_INLINE ::IR::EnumDef_ptr
+IR::EnumDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -5913,116 +9536,116 @@ CORBA_UnionDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_EnumDef::CORBA_EnumDef (void) // default constructor
+IR::AliasDef::AliasDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_EnumDef::CORBA_EnumDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::AliasDef::AliasDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_EnumDef::~CORBA_EnumDef (void) // destructor
+IR::AliasDef::~AliasDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_ENUMDEF___VAR_CI_)
-#define _CORBA_ENUMDEF___VAR_CI_
+#if !defined (_IR_ALIASDEF___VAR_CI_)
+#define _IR_ALIASDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_EnumDef_var
+// Inline operations for class IR::AliasDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_EnumDef_var::CORBA_EnumDef_var (void) // default constructor
-  : ptr_ (CORBA_EnumDef::_nil ())
+IR::AliasDef_var::AliasDef_var (void) // default constructor
+  : ptr_ (AliasDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_EnumDef_var::CORBA_EnumDef_var (CORBA_EnumDef_ptr p)
+IR::AliasDef_var::AliasDef_var (AliasDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_EnumDef_ptr 
-CORBA_EnumDef_var::ptr (void) const
+ACE_INLINE ::IR::AliasDef_ptr
+IR::AliasDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_EnumDef_var::CORBA_EnumDef_var (const CORBA_EnumDef_var &p) // copy constructor
-  : ptr_ (CORBA_EnumDef::_duplicate (p.ptr ()))
+IR::AliasDef_var::AliasDef_var (const ::IR::AliasDef_var &p) // copy constructor
+  : ptr_ (AliasDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_EnumDef_var::~CORBA_EnumDef_var (void) // destructor
+IR::AliasDef_var::~AliasDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_EnumDef_var &
-CORBA_EnumDef_var::operator= (CORBA_EnumDef_ptr p)
+ACE_INLINE IR::AliasDef_var &
+IR::AliasDef_var::operator= (AliasDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_EnumDef_var &
-CORBA_EnumDef_var::operator= (const CORBA_EnumDef_var &p)
+ACE_INLINE IR::AliasDef_var &
+IR::AliasDef_var::operator= (const ::IR::AliasDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_EnumDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::AliasDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_EnumDef_var::operator const CORBA_EnumDef_ptr &() const // cast
+IR::AliasDef_var::operator const ::IR::AliasDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_EnumDef_var::operator CORBA_EnumDef_ptr &() // cast 
+IR::AliasDef_var::operator ::IR::AliasDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumDef_ptr 
-CORBA_EnumDef_var::operator-> (void) const
+ACE_INLINE ::IR::AliasDef_ptr
+IR::AliasDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumDef_ptr
-CORBA_EnumDef_var::in (void) const
+ACE_INLINE ::IR::AliasDef_ptr
+IR::AliasDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumDef_ptr &
-CORBA_EnumDef_var::inout (void)
+ACE_INLINE ::IR::AliasDef_ptr &
+IR::AliasDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumDef_ptr &
-CORBA_EnumDef_var::out (void)
+ACE_INLINE ::IR::AliasDef_ptr &
+IR::AliasDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_EnumDef::_nil ();
+  this->ptr_ = ::IR::AliasDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumDef_ptr 
-CORBA_EnumDef_var::_retn (void)
+ACE_INLINE ::IR::AliasDef_ptr
+IR::AliasDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_EnumDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_EnumDef::_nil ();
+  ::IR::AliasDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::AliasDef::_nil ();
   return val;
 }
 
@@ -6030,68 +9653,68 @@ CORBA_EnumDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ENUMDEF___OUT_CI_)
-#define _CORBA_ENUMDEF___OUT_CI_
+#if !defined (_IR_ALIASDEF___OUT_CI_)
+#define _IR_ALIASDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_EnumDef_out
+// Inline operations for class IR::AliasDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_EnumDef_out::CORBA_EnumDef_out (CORBA_EnumDef_ptr &p)
+IR::AliasDef_out::AliasDef_out (AliasDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_EnumDef::_nil ();
+  this->ptr_ = ::IR::AliasDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_EnumDef_out::CORBA_EnumDef_out (CORBA_EnumDef_var &p) // constructor from _var
+IR::AliasDef_out::AliasDef_out (AliasDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_EnumDef::_nil ();
+  this->ptr_ = ::IR::AliasDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_EnumDef_out::CORBA_EnumDef_out (const CORBA_EnumDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_EnumDef_out&,p).ptr_)
+IR::AliasDef_out::AliasDef_out (const ::IR::AliasDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (AliasDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_EnumDef_out &
-CORBA_EnumDef_out::operator= (const CORBA_EnumDef_out &p)
+ACE_INLINE ::IR::AliasDef_out &
+IR::AliasDef_out::operator= (const ::IR::AliasDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_EnumDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (AliasDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_EnumDef_out &
-CORBA_EnumDef_out::operator= (const CORBA_EnumDef_var &p)
+ACE_INLINE IR::AliasDef_out &
+IR::AliasDef_out::operator= (const ::IR::AliasDef_var &p)
 {
-  this->ptr_ = CORBA_EnumDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::AliasDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_EnumDef_out &
-CORBA_EnumDef_out::operator= (CORBA_EnumDef_ptr p)
+ACE_INLINE IR::AliasDef_out &
+IR::AliasDef_out::operator= (AliasDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_EnumDef_out::operator CORBA_EnumDef_ptr &() // cast
+IR::AliasDef_out::operator ::IR::AliasDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumDef_ptr &
-CORBA_EnumDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::AliasDef_ptr &
+IR::AliasDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_EnumDef_ptr 
-CORBA_EnumDef_out::operator-> (void)
+ACE_INLINE ::IR::AliasDef_ptr
+IR::AliasDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -6100,116 +9723,116 @@ CORBA_EnumDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_AliasDef::CORBA_AliasDef (void) // default constructor
+IR::NativeDef::NativeDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_AliasDef::CORBA_AliasDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::NativeDef::NativeDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_AliasDef::~CORBA_AliasDef (void) // destructor
+IR::NativeDef::~NativeDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_ALIASDEF___VAR_CI_)
-#define _CORBA_ALIASDEF___VAR_CI_
+#if !defined (_IR_NATIVEDEF___VAR_CI_)
+#define _IR_NATIVEDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_AliasDef_var
+// Inline operations for class IR::NativeDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_AliasDef_var::CORBA_AliasDef_var (void) // default constructor
-  : ptr_ (CORBA_AliasDef::_nil ())
+IR::NativeDef_var::NativeDef_var (void) // default constructor
+  : ptr_ (NativeDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_AliasDef_var::CORBA_AliasDef_var (CORBA_AliasDef_ptr p)
+IR::NativeDef_var::NativeDef_var (NativeDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_AliasDef_ptr 
-CORBA_AliasDef_var::ptr (void) const
+ACE_INLINE ::IR::NativeDef_ptr
+IR::NativeDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_AliasDef_var::CORBA_AliasDef_var (const CORBA_AliasDef_var &p) // copy constructor
-  : ptr_ (CORBA_AliasDef::_duplicate (p.ptr ()))
+IR::NativeDef_var::NativeDef_var (const ::IR::NativeDef_var &p) // copy constructor
+  : ptr_ (NativeDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_AliasDef_var::~CORBA_AliasDef_var (void) // destructor
+IR::NativeDef_var::~NativeDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_AliasDef_var &
-CORBA_AliasDef_var::operator= (CORBA_AliasDef_ptr p)
+ACE_INLINE IR::NativeDef_var &
+IR::NativeDef_var::operator= (NativeDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_AliasDef_var &
-CORBA_AliasDef_var::operator= (const CORBA_AliasDef_var &p)
+ACE_INLINE IR::NativeDef_var &
+IR::NativeDef_var::operator= (const ::IR::NativeDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_AliasDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::NativeDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_AliasDef_var::operator const CORBA_AliasDef_ptr &() const // cast
+IR::NativeDef_var::operator const ::IR::NativeDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_AliasDef_var::operator CORBA_AliasDef_ptr &() // cast 
+IR::NativeDef_var::operator ::IR::NativeDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AliasDef_ptr 
-CORBA_AliasDef_var::operator-> (void) const
+ACE_INLINE ::IR::NativeDef_ptr
+IR::NativeDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AliasDef_ptr
-CORBA_AliasDef_var::in (void) const
+ACE_INLINE ::IR::NativeDef_ptr
+IR::NativeDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AliasDef_ptr &
-CORBA_AliasDef_var::inout (void)
+ACE_INLINE ::IR::NativeDef_ptr &
+IR::NativeDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AliasDef_ptr &
-CORBA_AliasDef_var::out (void)
+ACE_INLINE ::IR::NativeDef_ptr &
+IR::NativeDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_AliasDef::_nil ();
+  this->ptr_ = ::IR::NativeDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AliasDef_ptr 
-CORBA_AliasDef_var::_retn (void)
+ACE_INLINE ::IR::NativeDef_ptr
+IR::NativeDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_AliasDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_AliasDef::_nil ();
+  ::IR::NativeDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::NativeDef::_nil ();
   return val;
 }
 
@@ -6217,68 +9840,68 @@ CORBA_AliasDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ALIASDEF___OUT_CI_)
-#define _CORBA_ALIASDEF___OUT_CI_
+#if !defined (_IR_NATIVEDEF___OUT_CI_)
+#define _IR_NATIVEDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_AliasDef_out
+// Inline operations for class IR::NativeDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_AliasDef_out::CORBA_AliasDef_out (CORBA_AliasDef_ptr &p)
+IR::NativeDef_out::NativeDef_out (NativeDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_AliasDef::_nil ();
+  this->ptr_ = ::IR::NativeDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_AliasDef_out::CORBA_AliasDef_out (CORBA_AliasDef_var &p) // constructor from _var
+IR::NativeDef_out::NativeDef_out (NativeDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_AliasDef::_nil ();
+  this->ptr_ = ::IR::NativeDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_AliasDef_out::CORBA_AliasDef_out (const CORBA_AliasDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_AliasDef_out&,p).ptr_)
+IR::NativeDef_out::NativeDef_out (const ::IR::NativeDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (NativeDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_AliasDef_out &
-CORBA_AliasDef_out::operator= (const CORBA_AliasDef_out &p)
+ACE_INLINE ::IR::NativeDef_out &
+IR::NativeDef_out::operator= (const ::IR::NativeDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_AliasDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (NativeDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_AliasDef_out &
-CORBA_AliasDef_out::operator= (const CORBA_AliasDef_var &p)
+ACE_INLINE IR::NativeDef_out &
+IR::NativeDef_out::operator= (const ::IR::NativeDef_var &p)
 {
-  this->ptr_ = CORBA_AliasDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::NativeDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_AliasDef_out &
-CORBA_AliasDef_out::operator= (CORBA_AliasDef_ptr p)
+ACE_INLINE IR::NativeDef_out &
+IR::NativeDef_out::operator= (NativeDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_AliasDef_out::operator CORBA_AliasDef_ptr &() // cast
+IR::NativeDef_out::operator ::IR::NativeDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AliasDef_ptr &
-CORBA_AliasDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::NativeDef_ptr &
+IR::NativeDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AliasDef_ptr 
-CORBA_AliasDef_out::operator-> (void)
+ACE_INLINE ::IR::NativeDef_ptr
+IR::NativeDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -6287,116 +9910,116 @@ CORBA_AliasDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_PrimitiveDef::CORBA_PrimitiveDef (void) // default constructor
+IR::PrimitiveDef::PrimitiveDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_PrimitiveDef::CORBA_PrimitiveDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::PrimitiveDef::PrimitiveDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_PrimitiveDef::~CORBA_PrimitiveDef (void) // destructor
+IR::PrimitiveDef::~PrimitiveDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_PRIMITIVEDEF___VAR_CI_)
-#define _CORBA_PRIMITIVEDEF___VAR_CI_
+#if !defined (_IR_PRIMITIVEDEF___VAR_CI_)
+#define _IR_PRIMITIVEDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_PrimitiveDef_var
+// Inline operations for class IR::PrimitiveDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_PrimitiveDef_var::CORBA_PrimitiveDef_var (void) // default constructor
-  : ptr_ (CORBA_PrimitiveDef::_nil ())
+IR::PrimitiveDef_var::PrimitiveDef_var (void) // default constructor
+  : ptr_ (PrimitiveDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_PrimitiveDef_var::CORBA_PrimitiveDef_var (CORBA_PrimitiveDef_ptr p)
+IR::PrimitiveDef_var::PrimitiveDef_var (PrimitiveDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_PrimitiveDef_ptr 
-CORBA_PrimitiveDef_var::ptr (void) const
+ACE_INLINE ::IR::PrimitiveDef_ptr
+IR::PrimitiveDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_PrimitiveDef_var::CORBA_PrimitiveDef_var (const CORBA_PrimitiveDef_var &p) // copy constructor
-  : ptr_ (CORBA_PrimitiveDef::_duplicate (p.ptr ()))
+IR::PrimitiveDef_var::PrimitiveDef_var (const ::IR::PrimitiveDef_var &p) // copy constructor
+  : ptr_ (PrimitiveDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_PrimitiveDef_var::~CORBA_PrimitiveDef_var (void) // destructor
+IR::PrimitiveDef_var::~PrimitiveDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_PrimitiveDef_var &
-CORBA_PrimitiveDef_var::operator= (CORBA_PrimitiveDef_ptr p)
+ACE_INLINE IR::PrimitiveDef_var &
+IR::PrimitiveDef_var::operator= (PrimitiveDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_var &
-CORBA_PrimitiveDef_var::operator= (const CORBA_PrimitiveDef_var &p)
+ACE_INLINE IR::PrimitiveDef_var &
+IR::PrimitiveDef_var::operator= (const ::IR::PrimitiveDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_PrimitiveDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::PrimitiveDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_PrimitiveDef_var::operator const CORBA_PrimitiveDef_ptr &() const // cast
+IR::PrimitiveDef_var::operator const ::IR::PrimitiveDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_PrimitiveDef_var::operator CORBA_PrimitiveDef_ptr &() // cast 
+IR::PrimitiveDef_var::operator ::IR::PrimitiveDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_ptr 
-CORBA_PrimitiveDef_var::operator-> (void) const
+ACE_INLINE ::IR::PrimitiveDef_ptr
+IR::PrimitiveDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_ptr
-CORBA_PrimitiveDef_var::in (void) const
+ACE_INLINE ::IR::PrimitiveDef_ptr
+IR::PrimitiveDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_ptr &
-CORBA_PrimitiveDef_var::inout (void)
+ACE_INLINE ::IR::PrimitiveDef_ptr &
+IR::PrimitiveDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_ptr &
-CORBA_PrimitiveDef_var::out (void)
+ACE_INLINE ::IR::PrimitiveDef_ptr &
+IR::PrimitiveDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_PrimitiveDef::_nil ();
+  this->ptr_ = ::IR::PrimitiveDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_ptr 
-CORBA_PrimitiveDef_var::_retn (void)
+ACE_INLINE ::IR::PrimitiveDef_ptr
+IR::PrimitiveDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_PrimitiveDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_PrimitiveDef::_nil ();
+  ::IR::PrimitiveDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::PrimitiveDef::_nil ();
   return val;
 }
 
@@ -6404,68 +10027,68 @@ CORBA_PrimitiveDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_PRIMITIVEDEF___OUT_CI_)
-#define _CORBA_PRIMITIVEDEF___OUT_CI_
+#if !defined (_IR_PRIMITIVEDEF___OUT_CI_)
+#define _IR_PRIMITIVEDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_PrimitiveDef_out
+// Inline operations for class IR::PrimitiveDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_PrimitiveDef_out::CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_ptr &p)
+IR::PrimitiveDef_out::PrimitiveDef_out (PrimitiveDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_PrimitiveDef::_nil ();
+  this->ptr_ = ::IR::PrimitiveDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_PrimitiveDef_out::CORBA_PrimitiveDef_out (CORBA_PrimitiveDef_var &p) // constructor from _var
+IR::PrimitiveDef_out::PrimitiveDef_out (PrimitiveDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_PrimitiveDef::_nil ();
+  this->ptr_ = ::IR::PrimitiveDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_PrimitiveDef_out::CORBA_PrimitiveDef_out (const CORBA_PrimitiveDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_PrimitiveDef_out&,p).ptr_)
+IR::PrimitiveDef_out::PrimitiveDef_out (const ::IR::PrimitiveDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (PrimitiveDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_PrimitiveDef_out &
-CORBA_PrimitiveDef_out::operator= (const CORBA_PrimitiveDef_out &p)
+ACE_INLINE ::IR::PrimitiveDef_out &
+IR::PrimitiveDef_out::operator= (const ::IR::PrimitiveDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_PrimitiveDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (PrimitiveDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_out &
-CORBA_PrimitiveDef_out::operator= (const CORBA_PrimitiveDef_var &p)
+ACE_INLINE IR::PrimitiveDef_out &
+IR::PrimitiveDef_out::operator= (const ::IR::PrimitiveDef_var &p)
 {
-  this->ptr_ = CORBA_PrimitiveDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::PrimitiveDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_out &
-CORBA_PrimitiveDef_out::operator= (CORBA_PrimitiveDef_ptr p)
+ACE_INLINE IR::PrimitiveDef_out &
+IR::PrimitiveDef_out::operator= (PrimitiveDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_PrimitiveDef_out::operator CORBA_PrimitiveDef_ptr &() // cast
+IR::PrimitiveDef_out::operator ::IR::PrimitiveDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_ptr &
-CORBA_PrimitiveDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::PrimitiveDef_ptr &
+IR::PrimitiveDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_PrimitiveDef_ptr 
-CORBA_PrimitiveDef_out::operator-> (void)
+ACE_INLINE ::IR::PrimitiveDef_ptr
+IR::PrimitiveDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -6474,116 +10097,116 @@ CORBA_PrimitiveDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_StringDef::CORBA_StringDef (void) // default constructor
+IR::StringDef::StringDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_StringDef::CORBA_StringDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::StringDef::StringDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_StringDef::~CORBA_StringDef (void) // destructor
+IR::StringDef::~StringDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_STRINGDEF___VAR_CI_)
-#define _CORBA_STRINGDEF___VAR_CI_
+#if !defined (_IR_STRINGDEF___VAR_CI_)
+#define _IR_STRINGDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_StringDef_var
+// Inline operations for class IR::StringDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_StringDef_var::CORBA_StringDef_var (void) // default constructor
-  : ptr_ (CORBA_StringDef::_nil ())
+IR::StringDef_var::StringDef_var (void) // default constructor
+  : ptr_ (StringDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_StringDef_var::CORBA_StringDef_var (CORBA_StringDef_ptr p)
+IR::StringDef_var::StringDef_var (StringDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_StringDef_ptr 
-CORBA_StringDef_var::ptr (void) const
+ACE_INLINE ::IR::StringDef_ptr
+IR::StringDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_StringDef_var::CORBA_StringDef_var (const CORBA_StringDef_var &p) // copy constructor
-  : ptr_ (CORBA_StringDef::_duplicate (p.ptr ()))
+IR::StringDef_var::StringDef_var (const ::IR::StringDef_var &p) // copy constructor
+  : ptr_ (StringDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_StringDef_var::~CORBA_StringDef_var (void) // destructor
+IR::StringDef_var::~StringDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_StringDef_var &
-CORBA_StringDef_var::operator= (CORBA_StringDef_ptr p)
+ACE_INLINE IR::StringDef_var &
+IR::StringDef_var::operator= (StringDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_StringDef_var &
-CORBA_StringDef_var::operator= (const CORBA_StringDef_var &p)
+ACE_INLINE IR::StringDef_var &
+IR::StringDef_var::operator= (const ::IR::StringDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_StringDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::StringDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_StringDef_var::operator const CORBA_StringDef_ptr &() const // cast
+IR::StringDef_var::operator const ::IR::StringDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_StringDef_var::operator CORBA_StringDef_ptr &() // cast 
+IR::StringDef_var::operator ::IR::StringDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StringDef_ptr 
-CORBA_StringDef_var::operator-> (void) const
+ACE_INLINE ::IR::StringDef_ptr
+IR::StringDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StringDef_ptr
-CORBA_StringDef_var::in (void) const
+ACE_INLINE ::IR::StringDef_ptr
+IR::StringDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StringDef_ptr &
-CORBA_StringDef_var::inout (void)
+ACE_INLINE ::IR::StringDef_ptr &
+IR::StringDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StringDef_ptr &
-CORBA_StringDef_var::out (void)
+ACE_INLINE ::IR::StringDef_ptr &
+IR::StringDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_StringDef::_nil ();
+  this->ptr_ = ::IR::StringDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StringDef_ptr 
-CORBA_StringDef_var::_retn (void)
+ACE_INLINE ::IR::StringDef_ptr
+IR::StringDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_StringDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_StringDef::_nil ();
+  ::IR::StringDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::StringDef::_nil ();
   return val;
 }
 
@@ -6591,68 +10214,68 @@ CORBA_StringDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_STRINGDEF___OUT_CI_)
-#define _CORBA_STRINGDEF___OUT_CI_
+#if !defined (_IR_STRINGDEF___OUT_CI_)
+#define _IR_STRINGDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_StringDef_out
+// Inline operations for class IR::StringDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_StringDef_out::CORBA_StringDef_out (CORBA_StringDef_ptr &p)
+IR::StringDef_out::StringDef_out (StringDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_StringDef::_nil ();
+  this->ptr_ = ::IR::StringDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_StringDef_out::CORBA_StringDef_out (CORBA_StringDef_var &p) // constructor from _var
+IR::StringDef_out::StringDef_out (StringDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_StringDef::_nil ();
+  this->ptr_ = ::IR::StringDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_StringDef_out::CORBA_StringDef_out (const CORBA_StringDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_StringDef_out&,p).ptr_)
+IR::StringDef_out::StringDef_out (const ::IR::StringDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (StringDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_StringDef_out &
-CORBA_StringDef_out::operator= (const CORBA_StringDef_out &p)
+ACE_INLINE ::IR::StringDef_out &
+IR::StringDef_out::operator= (const ::IR::StringDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_StringDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (StringDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_StringDef_out &
-CORBA_StringDef_out::operator= (const CORBA_StringDef_var &p)
+ACE_INLINE IR::StringDef_out &
+IR::StringDef_out::operator= (const ::IR::StringDef_var &p)
 {
-  this->ptr_ = CORBA_StringDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::StringDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_StringDef_out &
-CORBA_StringDef_out::operator= (CORBA_StringDef_ptr p)
+ACE_INLINE IR::StringDef_out &
+IR::StringDef_out::operator= (StringDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_StringDef_out::operator CORBA_StringDef_ptr &() // cast
+IR::StringDef_out::operator ::IR::StringDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StringDef_ptr &
-CORBA_StringDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::StringDef_ptr &
+IR::StringDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_StringDef_ptr 
-CORBA_StringDef_out::operator-> (void)
+ACE_INLINE ::IR::StringDef_ptr
+IR::StringDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -6661,116 +10284,116 @@ CORBA_StringDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_WstringDef::CORBA_WstringDef (void) // default constructor
+IR::WstringDef::WstringDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_WstringDef::CORBA_WstringDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::WstringDef::WstringDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_WstringDef::~CORBA_WstringDef (void) // destructor
+IR::WstringDef::~WstringDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_WSTRINGDEF___VAR_CI_)
-#define _CORBA_WSTRINGDEF___VAR_CI_
+#if !defined (_IR_WSTRINGDEF___VAR_CI_)
+#define _IR_WSTRINGDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_WstringDef_var
+// Inline operations for class IR::WstringDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_WstringDef_var::CORBA_WstringDef_var (void) // default constructor
-  : ptr_ (CORBA_WstringDef::_nil ())
+IR::WstringDef_var::WstringDef_var (void) // default constructor
+  : ptr_ (WstringDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_WstringDef_var::CORBA_WstringDef_var (CORBA_WstringDef_ptr p)
+IR::WstringDef_var::WstringDef_var (WstringDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_WstringDef_ptr 
-CORBA_WstringDef_var::ptr (void) const
+ACE_INLINE ::IR::WstringDef_ptr
+IR::WstringDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_WstringDef_var::CORBA_WstringDef_var (const CORBA_WstringDef_var &p) // copy constructor
-  : ptr_ (CORBA_WstringDef::_duplicate (p.ptr ()))
+IR::WstringDef_var::WstringDef_var (const ::IR::WstringDef_var &p) // copy constructor
+  : ptr_ (WstringDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_WstringDef_var::~CORBA_WstringDef_var (void) // destructor
+IR::WstringDef_var::~WstringDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_WstringDef_var &
-CORBA_WstringDef_var::operator= (CORBA_WstringDef_ptr p)
+ACE_INLINE IR::WstringDef_var &
+IR::WstringDef_var::operator= (WstringDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_WstringDef_var &
-CORBA_WstringDef_var::operator= (const CORBA_WstringDef_var &p)
+ACE_INLINE IR::WstringDef_var &
+IR::WstringDef_var::operator= (const ::IR::WstringDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_WstringDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::WstringDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_WstringDef_var::operator const CORBA_WstringDef_ptr &() const // cast
+IR::WstringDef_var::operator const ::IR::WstringDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_WstringDef_var::operator CORBA_WstringDef_ptr &() // cast 
+IR::WstringDef_var::operator ::IR::WstringDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_WstringDef_ptr 
-CORBA_WstringDef_var::operator-> (void) const
+ACE_INLINE ::IR::WstringDef_ptr
+IR::WstringDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_WstringDef_ptr
-CORBA_WstringDef_var::in (void) const
+ACE_INLINE ::IR::WstringDef_ptr
+IR::WstringDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_WstringDef_ptr &
-CORBA_WstringDef_var::inout (void)
+ACE_INLINE ::IR::WstringDef_ptr &
+IR::WstringDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_WstringDef_ptr &
-CORBA_WstringDef_var::out (void)
+ACE_INLINE ::IR::WstringDef_ptr &
+IR::WstringDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_WstringDef::_nil ();
+  this->ptr_ = ::IR::WstringDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_WstringDef_ptr 
-CORBA_WstringDef_var::_retn (void)
+ACE_INLINE ::IR::WstringDef_ptr
+IR::WstringDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_WstringDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_WstringDef::_nil ();
+  ::IR::WstringDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::WstringDef::_nil ();
   return val;
 }
 
@@ -6778,68 +10401,68 @@ CORBA_WstringDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_WSTRINGDEF___OUT_CI_)
-#define _CORBA_WSTRINGDEF___OUT_CI_
+#if !defined (_IR_WSTRINGDEF___OUT_CI_)
+#define _IR_WSTRINGDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_WstringDef_out
+// Inline operations for class IR::WstringDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_WstringDef_out::CORBA_WstringDef_out (CORBA_WstringDef_ptr &p)
+IR::WstringDef_out::WstringDef_out (WstringDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_WstringDef::_nil ();
+  this->ptr_ = ::IR::WstringDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_WstringDef_out::CORBA_WstringDef_out (CORBA_WstringDef_var &p) // constructor from _var
+IR::WstringDef_out::WstringDef_out (WstringDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_WstringDef::_nil ();
+  this->ptr_ = ::IR::WstringDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_WstringDef_out::CORBA_WstringDef_out (const CORBA_WstringDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_WstringDef_out&,p).ptr_)
+IR::WstringDef_out::WstringDef_out (const ::IR::WstringDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (WstringDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_WstringDef_out &
-CORBA_WstringDef_out::operator= (const CORBA_WstringDef_out &p)
+ACE_INLINE ::IR::WstringDef_out &
+IR::WstringDef_out::operator= (const ::IR::WstringDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_WstringDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (WstringDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_WstringDef_out &
-CORBA_WstringDef_out::operator= (const CORBA_WstringDef_var &p)
+ACE_INLINE IR::WstringDef_out &
+IR::WstringDef_out::operator= (const ::IR::WstringDef_var &p)
 {
-  this->ptr_ = CORBA_WstringDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::WstringDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_WstringDef_out &
-CORBA_WstringDef_out::operator= (CORBA_WstringDef_ptr p)
+ACE_INLINE IR::WstringDef_out &
+IR::WstringDef_out::operator= (WstringDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_WstringDef_out::operator CORBA_WstringDef_ptr &() // cast
+IR::WstringDef_out::operator ::IR::WstringDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_WstringDef_ptr &
-CORBA_WstringDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::WstringDef_ptr &
+IR::WstringDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_WstringDef_ptr 
-CORBA_WstringDef_out::operator-> (void)
+ACE_INLINE ::IR::WstringDef_ptr
+IR::WstringDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -6848,116 +10471,116 @@ CORBA_WstringDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_FixedDef::CORBA_FixedDef (void) // default constructor
+IR::FixedDef::FixedDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_FixedDef::CORBA_FixedDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::FixedDef::FixedDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_FixedDef::~CORBA_FixedDef (void) // destructor
+IR::FixedDef::~FixedDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_FIXEDDEF___VAR_CI_)
-#define _CORBA_FIXEDDEF___VAR_CI_
+#if !defined (_IR_FIXEDDEF___VAR_CI_)
+#define _IR_FIXEDDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_FixedDef_var
+// Inline operations for class IR::FixedDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_FixedDef_var::CORBA_FixedDef_var (void) // default constructor
-  : ptr_ (CORBA_FixedDef::_nil ())
+IR::FixedDef_var::FixedDef_var (void) // default constructor
+  : ptr_ (FixedDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_FixedDef_var::CORBA_FixedDef_var (CORBA_FixedDef_ptr p)
+IR::FixedDef_var::FixedDef_var (FixedDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_FixedDef_ptr 
-CORBA_FixedDef_var::ptr (void) const
+ACE_INLINE ::IR::FixedDef_ptr
+IR::FixedDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_FixedDef_var::CORBA_FixedDef_var (const CORBA_FixedDef_var &p) // copy constructor
-  : ptr_ (CORBA_FixedDef::_duplicate (p.ptr ()))
+IR::FixedDef_var::FixedDef_var (const ::IR::FixedDef_var &p) // copy constructor
+  : ptr_ (FixedDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_FixedDef_var::~CORBA_FixedDef_var (void) // destructor
+IR::FixedDef_var::~FixedDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_FixedDef_var &
-CORBA_FixedDef_var::operator= (CORBA_FixedDef_ptr p)
+ACE_INLINE IR::FixedDef_var &
+IR::FixedDef_var::operator= (FixedDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_FixedDef_var &
-CORBA_FixedDef_var::operator= (const CORBA_FixedDef_var &p)
+ACE_INLINE IR::FixedDef_var &
+IR::FixedDef_var::operator= (const ::IR::FixedDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_FixedDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::FixedDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_FixedDef_var::operator const CORBA_FixedDef_ptr &() const // cast
+IR::FixedDef_var::operator const ::IR::FixedDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_FixedDef_var::operator CORBA_FixedDef_ptr &() // cast 
+IR::FixedDef_var::operator ::IR::FixedDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_FixedDef_ptr 
-CORBA_FixedDef_var::operator-> (void) const
+ACE_INLINE ::IR::FixedDef_ptr
+IR::FixedDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_FixedDef_ptr
-CORBA_FixedDef_var::in (void) const
+ACE_INLINE ::IR::FixedDef_ptr
+IR::FixedDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_FixedDef_ptr &
-CORBA_FixedDef_var::inout (void)
+ACE_INLINE ::IR::FixedDef_ptr &
+IR::FixedDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_FixedDef_ptr &
-CORBA_FixedDef_var::out (void)
+ACE_INLINE ::IR::FixedDef_ptr &
+IR::FixedDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_FixedDef::_nil ();
+  this->ptr_ = ::IR::FixedDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_FixedDef_ptr 
-CORBA_FixedDef_var::_retn (void)
+ACE_INLINE ::IR::FixedDef_ptr
+IR::FixedDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_FixedDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_FixedDef::_nil ();
+  ::IR::FixedDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::FixedDef::_nil ();
   return val;
 }
 
@@ -6965,68 +10588,68 @@ CORBA_FixedDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_FIXEDDEF___OUT_CI_)
-#define _CORBA_FIXEDDEF___OUT_CI_
+#if !defined (_IR_FIXEDDEF___OUT_CI_)
+#define _IR_FIXEDDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_FixedDef_out
+// Inline operations for class IR::FixedDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_FixedDef_out::CORBA_FixedDef_out (CORBA_FixedDef_ptr &p)
+IR::FixedDef_out::FixedDef_out (FixedDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_FixedDef::_nil ();
+  this->ptr_ = ::IR::FixedDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_FixedDef_out::CORBA_FixedDef_out (CORBA_FixedDef_var &p) // constructor from _var
+IR::FixedDef_out::FixedDef_out (FixedDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_FixedDef::_nil ();
+  this->ptr_ = ::IR::FixedDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_FixedDef_out::CORBA_FixedDef_out (const CORBA_FixedDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_FixedDef_out&,p).ptr_)
+IR::FixedDef_out::FixedDef_out (const ::IR::FixedDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (FixedDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_FixedDef_out &
-CORBA_FixedDef_out::operator= (const CORBA_FixedDef_out &p)
+ACE_INLINE ::IR::FixedDef_out &
+IR::FixedDef_out::operator= (const ::IR::FixedDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_FixedDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (FixedDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_FixedDef_out &
-CORBA_FixedDef_out::operator= (const CORBA_FixedDef_var &p)
+ACE_INLINE IR::FixedDef_out &
+IR::FixedDef_out::operator= (const ::IR::FixedDef_var &p)
 {
-  this->ptr_ = CORBA_FixedDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::FixedDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_FixedDef_out &
-CORBA_FixedDef_out::operator= (CORBA_FixedDef_ptr p)
+ACE_INLINE IR::FixedDef_out &
+IR::FixedDef_out::operator= (FixedDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_FixedDef_out::operator CORBA_FixedDef_ptr &() // cast
+IR::FixedDef_out::operator ::IR::FixedDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_FixedDef_ptr &
-CORBA_FixedDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::FixedDef_ptr &
+IR::FixedDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_FixedDef_ptr 
-CORBA_FixedDef_out::operator-> (void)
+ACE_INLINE ::IR::FixedDef_ptr
+IR::FixedDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -7035,116 +10658,116 @@ CORBA_FixedDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_SequenceDef::CORBA_SequenceDef (void) // default constructor
+IR::SequenceDef::SequenceDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_SequenceDef::CORBA_SequenceDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::SequenceDef::SequenceDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_SequenceDef::~CORBA_SequenceDef (void) // destructor
+IR::SequenceDef::~SequenceDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_SEQUENCEDEF___VAR_CI_)
-#define _CORBA_SEQUENCEDEF___VAR_CI_
+#if !defined (_IR_SEQUENCEDEF___VAR_CI_)
+#define _IR_SEQUENCEDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_SequenceDef_var
+// Inline operations for class IR::SequenceDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_SequenceDef_var::CORBA_SequenceDef_var (void) // default constructor
-  : ptr_ (CORBA_SequenceDef::_nil ())
+IR::SequenceDef_var::SequenceDef_var (void) // default constructor
+  : ptr_ (SequenceDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_SequenceDef_var::CORBA_SequenceDef_var (CORBA_SequenceDef_ptr p)
+IR::SequenceDef_var::SequenceDef_var (SequenceDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_SequenceDef_ptr 
-CORBA_SequenceDef_var::ptr (void) const
+ACE_INLINE ::IR::SequenceDef_ptr
+IR::SequenceDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_SequenceDef_var::CORBA_SequenceDef_var (const CORBA_SequenceDef_var &p) // copy constructor
-  : ptr_ (CORBA_SequenceDef::_duplicate (p.ptr ()))
+IR::SequenceDef_var::SequenceDef_var (const ::IR::SequenceDef_var &p) // copy constructor
+  : ptr_ (SequenceDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_SequenceDef_var::~CORBA_SequenceDef_var (void) // destructor
+IR::SequenceDef_var::~SequenceDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_SequenceDef_var &
-CORBA_SequenceDef_var::operator= (CORBA_SequenceDef_ptr p)
+ACE_INLINE IR::SequenceDef_var &
+IR::SequenceDef_var::operator= (SequenceDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_SequenceDef_var &
-CORBA_SequenceDef_var::operator= (const CORBA_SequenceDef_var &p)
+ACE_INLINE IR::SequenceDef_var &
+IR::SequenceDef_var::operator= (const ::IR::SequenceDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_SequenceDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::SequenceDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_SequenceDef_var::operator const CORBA_SequenceDef_ptr &() const // cast
+IR::SequenceDef_var::operator const ::IR::SequenceDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_SequenceDef_var::operator CORBA_SequenceDef_ptr &() // cast 
+IR::SequenceDef_var::operator ::IR::SequenceDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_SequenceDef_ptr 
-CORBA_SequenceDef_var::operator-> (void) const
+ACE_INLINE ::IR::SequenceDef_ptr
+IR::SequenceDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_SequenceDef_ptr
-CORBA_SequenceDef_var::in (void) const
+ACE_INLINE ::IR::SequenceDef_ptr
+IR::SequenceDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_SequenceDef_ptr &
-CORBA_SequenceDef_var::inout (void)
+ACE_INLINE ::IR::SequenceDef_ptr &
+IR::SequenceDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_SequenceDef_ptr &
-CORBA_SequenceDef_var::out (void)
+ACE_INLINE ::IR::SequenceDef_ptr &
+IR::SequenceDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_SequenceDef::_nil ();
+  this->ptr_ = ::IR::SequenceDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_SequenceDef_ptr 
-CORBA_SequenceDef_var::_retn (void)
+ACE_INLINE ::IR::SequenceDef_ptr
+IR::SequenceDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_SequenceDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_SequenceDef::_nil ();
+  ::IR::SequenceDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::SequenceDef::_nil ();
   return val;
 }
 
@@ -7152,68 +10775,68 @@ CORBA_SequenceDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_SEQUENCEDEF___OUT_CI_)
-#define _CORBA_SEQUENCEDEF___OUT_CI_
+#if !defined (_IR_SEQUENCEDEF___OUT_CI_)
+#define _IR_SEQUENCEDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_SequenceDef_out
+// Inline operations for class IR::SequenceDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_SequenceDef_out::CORBA_SequenceDef_out (CORBA_SequenceDef_ptr &p)
+IR::SequenceDef_out::SequenceDef_out (SequenceDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_SequenceDef::_nil ();
+  this->ptr_ = ::IR::SequenceDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_SequenceDef_out::CORBA_SequenceDef_out (CORBA_SequenceDef_var &p) // constructor from _var
+IR::SequenceDef_out::SequenceDef_out (SequenceDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_SequenceDef::_nil ();
+  this->ptr_ = ::IR::SequenceDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_SequenceDef_out::CORBA_SequenceDef_out (const CORBA_SequenceDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_SequenceDef_out&,p).ptr_)
+IR::SequenceDef_out::SequenceDef_out (const ::IR::SequenceDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (SequenceDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_SequenceDef_out &
-CORBA_SequenceDef_out::operator= (const CORBA_SequenceDef_out &p)
+ACE_INLINE ::IR::SequenceDef_out &
+IR::SequenceDef_out::operator= (const ::IR::SequenceDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_SequenceDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (SequenceDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_SequenceDef_out &
-CORBA_SequenceDef_out::operator= (const CORBA_SequenceDef_var &p)
+ACE_INLINE IR::SequenceDef_out &
+IR::SequenceDef_out::operator= (const ::IR::SequenceDef_var &p)
 {
-  this->ptr_ = CORBA_SequenceDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::SequenceDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_SequenceDef_out &
-CORBA_SequenceDef_out::operator= (CORBA_SequenceDef_ptr p)
+ACE_INLINE IR::SequenceDef_out &
+IR::SequenceDef_out::operator= (SequenceDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_SequenceDef_out::operator CORBA_SequenceDef_ptr &() // cast
+IR::SequenceDef_out::operator ::IR::SequenceDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_SequenceDef_ptr &
-CORBA_SequenceDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::SequenceDef_ptr &
+IR::SequenceDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_SequenceDef_ptr 
-CORBA_SequenceDef_out::operator-> (void)
+ACE_INLINE ::IR::SequenceDef_ptr
+IR::SequenceDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -7222,116 +10845,116 @@ CORBA_SequenceDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_ArrayDef::CORBA_ArrayDef (void) // default constructor
+IR::ArrayDef::ArrayDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_ArrayDef::CORBA_ArrayDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::ArrayDef::ArrayDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_ArrayDef::~CORBA_ArrayDef (void) // destructor
+IR::ArrayDef::~ArrayDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_ARRAYDEF___VAR_CI_)
-#define _CORBA_ARRAYDEF___VAR_CI_
+#if !defined (_IR_ARRAYDEF___VAR_CI_)
+#define _IR_ARRAYDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ArrayDef_var
+// Inline operations for class IR::ArrayDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ArrayDef_var::CORBA_ArrayDef_var (void) // default constructor
-  : ptr_ (CORBA_ArrayDef::_nil ())
+IR::ArrayDef_var::ArrayDef_var (void) // default constructor
+  : ptr_ (ArrayDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_ArrayDef_var::CORBA_ArrayDef_var (CORBA_ArrayDef_ptr p)
+IR::ArrayDef_var::ArrayDef_var (ArrayDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_ArrayDef_ptr 
-CORBA_ArrayDef_var::ptr (void) const
+ACE_INLINE ::IR::ArrayDef_ptr
+IR::ArrayDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ArrayDef_var::CORBA_ArrayDef_var (const CORBA_ArrayDef_var &p) // copy constructor
-  : ptr_ (CORBA_ArrayDef::_duplicate (p.ptr ()))
+IR::ArrayDef_var::ArrayDef_var (const ::IR::ArrayDef_var &p) // copy constructor
+  : ptr_ (ArrayDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_ArrayDef_var::~CORBA_ArrayDef_var (void) // destructor
+IR::ArrayDef_var::~ArrayDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_ArrayDef_var &
-CORBA_ArrayDef_var::operator= (CORBA_ArrayDef_ptr p)
+ACE_INLINE IR::ArrayDef_var &
+IR::ArrayDef_var::operator= (ArrayDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ArrayDef_var &
-CORBA_ArrayDef_var::operator= (const CORBA_ArrayDef_var &p)
+ACE_INLINE IR::ArrayDef_var &
+IR::ArrayDef_var::operator= (const ::IR::ArrayDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_ArrayDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::ArrayDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ArrayDef_var::operator const CORBA_ArrayDef_ptr &() const // cast
+IR::ArrayDef_var::operator const ::IR::ArrayDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ArrayDef_var::operator CORBA_ArrayDef_ptr &() // cast 
+IR::ArrayDef_var::operator ::IR::ArrayDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ArrayDef_ptr 
-CORBA_ArrayDef_var::operator-> (void) const
+ACE_INLINE ::IR::ArrayDef_ptr
+IR::ArrayDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ArrayDef_ptr
-CORBA_ArrayDef_var::in (void) const
+ACE_INLINE ::IR::ArrayDef_ptr
+IR::ArrayDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ArrayDef_ptr &
-CORBA_ArrayDef_var::inout (void)
+ACE_INLINE ::IR::ArrayDef_ptr &
+IR::ArrayDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ArrayDef_ptr &
-CORBA_ArrayDef_var::out (void)
+ACE_INLINE ::IR::ArrayDef_ptr &
+IR::ArrayDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ArrayDef::_nil ();
+  this->ptr_ = ::IR::ArrayDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ArrayDef_ptr 
-CORBA_ArrayDef_var::_retn (void)
+ACE_INLINE ::IR::ArrayDef_ptr
+IR::ArrayDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_ArrayDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_ArrayDef::_nil ();
+  ::IR::ArrayDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ArrayDef::_nil ();
   return val;
 }
 
@@ -7339,68 +10962,68 @@ CORBA_ArrayDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ARRAYDEF___OUT_CI_)
-#define _CORBA_ARRAYDEF___OUT_CI_
+#if !defined (_IR_ARRAYDEF___OUT_CI_)
+#define _IR_ARRAYDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ArrayDef_out
+// Inline operations for class IR::ArrayDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ArrayDef_out::CORBA_ArrayDef_out (CORBA_ArrayDef_ptr &p)
+IR::ArrayDef_out::ArrayDef_out (ArrayDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_ArrayDef::_nil ();
+  this->ptr_ = ::IR::ArrayDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_ArrayDef_out::CORBA_ArrayDef_out (CORBA_ArrayDef_var &p) // constructor from _var
+IR::ArrayDef_out::ArrayDef_out (ArrayDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ArrayDef::_nil ();
+  this->ptr_ = ::IR::ArrayDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_ArrayDef_out::CORBA_ArrayDef_out (const CORBA_ArrayDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ArrayDef_out&,p).ptr_)
+IR::ArrayDef_out::ArrayDef_out (const ::IR::ArrayDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ArrayDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ArrayDef_out &
-CORBA_ArrayDef_out::operator= (const CORBA_ArrayDef_out &p)
+ACE_INLINE ::IR::ArrayDef_out &
+IR::ArrayDef_out::operator= (const ::IR::ArrayDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ArrayDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ArrayDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ArrayDef_out &
-CORBA_ArrayDef_out::operator= (const CORBA_ArrayDef_var &p)
+ACE_INLINE IR::ArrayDef_out &
+IR::ArrayDef_out::operator= (const ::IR::ArrayDef_var &p)
 {
-  this->ptr_ = CORBA_ArrayDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::ArrayDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_ArrayDef_out &
-CORBA_ArrayDef_out::operator= (CORBA_ArrayDef_ptr p)
+ACE_INLINE IR::ArrayDef_out &
+IR::ArrayDef_out::operator= (ArrayDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ArrayDef_out::operator CORBA_ArrayDef_ptr &() // cast
+IR::ArrayDef_out::operator ::IR::ArrayDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ArrayDef_ptr &
-CORBA_ArrayDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::ArrayDef_ptr &
+IR::ArrayDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ArrayDef_ptr 
-CORBA_ArrayDef_out::operator-> (void)
+ACE_INLINE ::IR::ArrayDef_ptr
+IR::ArrayDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -7409,116 +11032,116 @@ CORBA_ArrayDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_ExceptionDef::CORBA_ExceptionDef (void) // default constructor
+IR::ExceptionDef::ExceptionDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_ExceptionDef::CORBA_ExceptionDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::ExceptionDef::ExceptionDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_ExceptionDef::~CORBA_ExceptionDef (void) // destructor
+IR::ExceptionDef::~ExceptionDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_EXCEPTIONDEF___VAR_CI_)
-#define _CORBA_EXCEPTIONDEF___VAR_CI_
+#if !defined (_IR_EXCEPTIONDEF___VAR_CI_)
+#define _IR_EXCEPTIONDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ExceptionDef_var
+// Inline operations for class IR::ExceptionDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ExceptionDef_var::CORBA_ExceptionDef_var (void) // default constructor
-  : ptr_ (CORBA_ExceptionDef::_nil ())
+IR::ExceptionDef_var::ExceptionDef_var (void) // default constructor
+  : ptr_ (ExceptionDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_ExceptionDef_var::CORBA_ExceptionDef_var (CORBA_ExceptionDef_ptr p)
+IR::ExceptionDef_var::ExceptionDef_var (ExceptionDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_ExceptionDef_ptr 
-CORBA_ExceptionDef_var::ptr (void) const
+ACE_INLINE ::IR::ExceptionDef_ptr
+IR::ExceptionDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ExceptionDef_var::CORBA_ExceptionDef_var (const CORBA_ExceptionDef_var &p) // copy constructor
-  : ptr_ (CORBA_ExceptionDef::_duplicate (p.ptr ()))
+IR::ExceptionDef_var::ExceptionDef_var (const ::IR::ExceptionDef_var &p) // copy constructor
+  : ptr_ (ExceptionDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_ExceptionDef_var::~CORBA_ExceptionDef_var (void) // destructor
+IR::ExceptionDef_var::~ExceptionDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_ExceptionDef_var &
-CORBA_ExceptionDef_var::operator= (CORBA_ExceptionDef_ptr p)
+ACE_INLINE IR::ExceptionDef_var &
+IR::ExceptionDef_var::operator= (ExceptionDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ExceptionDef_var &
-CORBA_ExceptionDef_var::operator= (const CORBA_ExceptionDef_var &p)
+ACE_INLINE IR::ExceptionDef_var &
+IR::ExceptionDef_var::operator= (const ::IR::ExceptionDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_ExceptionDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::ExceptionDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDef_var::operator const CORBA_ExceptionDef_ptr &() const // cast
+IR::ExceptionDef_var::operator const ::IR::ExceptionDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDef_var::operator CORBA_ExceptionDef_ptr &() // cast 
+IR::ExceptionDef_var::operator ::IR::ExceptionDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDef_ptr 
-CORBA_ExceptionDef_var::operator-> (void) const
+ACE_INLINE ::IR::ExceptionDef_ptr
+IR::ExceptionDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDef_ptr
-CORBA_ExceptionDef_var::in (void) const
+ACE_INLINE ::IR::ExceptionDef_ptr
+IR::ExceptionDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDef_ptr &
-CORBA_ExceptionDef_var::inout (void)
+ACE_INLINE ::IR::ExceptionDef_ptr &
+IR::ExceptionDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDef_ptr &
-CORBA_ExceptionDef_var::out (void)
+ACE_INLINE ::IR::ExceptionDef_ptr &
+IR::ExceptionDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ExceptionDef::_nil ();
+  this->ptr_ = ::IR::ExceptionDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDef_ptr 
-CORBA_ExceptionDef_var::_retn (void)
+ACE_INLINE ::IR::ExceptionDef_ptr
+IR::ExceptionDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_ExceptionDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_ExceptionDef::_nil ();
+  ::IR::ExceptionDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ExceptionDef::_nil ();
   return val;
 }
 
@@ -7526,204 +11149,919 @@ CORBA_ExceptionDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_EXCEPTIONDEF___OUT_CI_)
-#define _CORBA_EXCEPTIONDEF___OUT_CI_
+#if !defined (_IR_EXCEPTIONDEF___OUT_CI_)
+#define _IR_EXCEPTIONDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ExceptionDef_out
+// Inline operations for class IR::ExceptionDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ExceptionDef_out::CORBA_ExceptionDef_out (CORBA_ExceptionDef_ptr &p)
+IR::ExceptionDef_out::ExceptionDef_out (ExceptionDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_ExceptionDef::_nil ();
+  this->ptr_ = ::IR::ExceptionDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_ExceptionDef_out::CORBA_ExceptionDef_out (CORBA_ExceptionDef_var &p) // constructor from _var
+IR::ExceptionDef_out::ExceptionDef_out (ExceptionDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ExceptionDef::_nil ();
+  this->ptr_ = ::IR::ExceptionDef::_nil ();
+}
+
+ACE_INLINE
+IR::ExceptionDef_out::ExceptionDef_out (const ::IR::ExceptionDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ExceptionDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ExceptionDef_out &
+IR::ExceptionDef_out::operator= (const ::IR::ExceptionDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (ExceptionDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ExceptionDef_out &
+IR::ExceptionDef_out::operator= (const ::IR::ExceptionDef_var &p)
+{
+  this->ptr_ = ::IR::ExceptionDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ExceptionDef_out &
+IR::ExceptionDef_out::operator= (ExceptionDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ExceptionDef_out::operator ::IR::ExceptionDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDef_ptr &
+IR::ExceptionDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDef_ptr
+IR::ExceptionDef_out::operator-> (void)
+{
+  return this->ptr_;
 }
 
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class IR::ExceptionDescription_var
+// *************************************************************
+
 ACE_INLINE
-CORBA_ExceptionDef_out::CORBA_ExceptionDef_out (const CORBA_ExceptionDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ExceptionDef_out&,p).ptr_)
+IR::ExceptionDescription_var::ExceptionDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ExceptionDescription_var::ExceptionDescription_var (ExceptionDescription *p)
+  : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_ExceptionDef_out &
-CORBA_ExceptionDef_out::operator= (const CORBA_ExceptionDef_out &p)
+ACE_INLINE
+IR::ExceptionDescription_var::ExceptionDescription_var (const ::IR::ExceptionDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ExceptionDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ExceptionDescription_var::~ExceptionDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ExceptionDescription_var &
+IR::ExceptionDescription_var::operator= (ExceptionDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::ExceptionDescription_var &
+IR::ExceptionDescription_var::operator= (const ::IR::ExceptionDescription_var &p)
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::ExceptionDescription (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::ExceptionDescription *
+IR::ExceptionDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDescription *
+IR::ExceptionDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ExceptionDescription_var::operator const ::IR::ExceptionDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::ExceptionDescription_var::operator ::IR::ExceptionDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::ExceptionDescription_var::operator ::IR::ExceptionDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ExceptionDescription_var::operator ::IR::ExceptionDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::ExceptionDescription &
+IR::ExceptionDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDescription &
+IR::ExceptionDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ExceptionDescription *&
+IR::ExceptionDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDescription *
+IR::ExceptionDescription_var::_retn (void)
+{
+  ::IR::ExceptionDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ExceptionDescription *
+IR::ExceptionDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ExceptionDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::ExceptionDescription_out::ExceptionDescription_out (::IR::ExceptionDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ExceptionDescription_out::ExceptionDescription_out (ExceptionDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ExceptionDescription_out::ExceptionDescription_out (const ::IR::ExceptionDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ExceptionDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::ExceptionDescription_out &
+IR::ExceptionDescription_out::operator= (const ::IR::ExceptionDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (ExceptionDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ExceptionDescription_out &
+IR::ExceptionDescription_out::operator= (ExceptionDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ExceptionDescription_out::operator ::IR::ExceptionDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDescription *&
+IR::ExceptionDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDescription *
+IR::ExceptionDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EXCEPTIONDEFSEQ_CI_)
+#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_IR_EXCEPTIONDEFSEQ_CI_
+
+  ACE_INLINE IR::ExceptionDef **
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (CORBA::ULong nelems)
+  {
+    IR::ExceptionDef **buf = 0;
+    
+    ACE_NEW_RETURN (buf, IR::ExceptionDef*[nelems], 0);
+    
+    for (CORBA::ULong i = 0; i < nelems; i++)
+      buf[i] = IR::ExceptionDef::_nil ();
+    
+    return buf;
+  }
+  
+  ACE_INLINE void 
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::freebuf (IR::ExceptionDef **buffer)
+  {
+    if (buffer == 0)
+      return;
+    delete[] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (void)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum)
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::ExceptionDef* *value,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &rhs)
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::ExceptionDef **tmp1 = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (this->maximum_);
+      IR::ExceptionDef ** const tmp2 = ACE_reinterpret_cast (IR::ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+        tmp1[i] = IR::ExceptionDef::_duplicate (tmp2[i]);
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq &rhs)
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      IR::ExceptionDef **tmp = ACE_reinterpret_cast (IR::ExceptionDef **, this->buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+      {
+        CORBA::release (tmp[i]);
+        tmp[i] = IR::ExceptionDef::_nil ();
+      }
+      if (this->maximum_ < rhs.maximum_)
+      {
+        _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::ExceptionDef **tmp1 = ACE_reinterpret_cast (IR::ExceptionDef **, this->buffer_);
+    IR::ExceptionDef ** const tmp2 = ACE_reinterpret_cast (IR::ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
+      tmp1[i] = IR::ExceptionDef::_duplicate (tmp2[i]);
+    
+    return *this;
+  }
+  
+  ACE_INLINE TAO_Object_Manager<IR::ExceptionDef,IR::ExceptionDef_var>
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::operator[] (CORBA::ULong index) const
+  // read-write accessor
+  {
+    ACE_ASSERT (index < this->maximum_);
+    IR::ExceptionDef ** const tmp = ACE_reinterpret_cast (IR::ExceptionDef ** ACE_CAST_CONST, this->buffer_);
+    return TAO_Object_Manager<IR::ExceptionDef,IR::ExceptionDef_var> (tmp + index, this->release_);
+  }
+  
+  ACE_INLINE IR::ExceptionDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::ExceptionDef **result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::allocbuf (this->maximum_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::ExceptionDef**, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::ExceptionDef**,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::ExceptionDef* *
+  IR::_TAO_Unbounded_Object_Sequence_IR_ExceptionDefSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::ExceptionDef ** ACE_CAST_CONST, this->buffer_);
+  }
+  
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EXCEPTIONDEFSEQ_CI_)
+#define _IR_EXCEPTIONDEFSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::ExceptionDefSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::ExceptionDefSeq_var::ExceptionDefSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::ExceptionDefSeq_var::ExceptionDefSeq_var (ExceptionDefSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::ExceptionDefSeq_var::ExceptionDefSeq_var (const ::IR::ExceptionDefSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::ExceptionDefSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ExceptionDefSeq_var::~ExceptionDefSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::ExceptionDefSeq_var &
+IR::ExceptionDefSeq_var::operator= (ExceptionDefSeq *p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ExceptionDef_out&,p).ptr_;
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ExceptionDefSeq_var &
+IR::ExceptionDefSeq_var::operator= (const ::IR::ExceptionDefSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::ExceptionDefSeq (*p.ptr_), *this);
+  }
   return *this;
 }
 
-ACE_INLINE CORBA_ExceptionDef_out &
-CORBA_ExceptionDef_out::operator= (const CORBA_ExceptionDef_var &p)
+ACE_INLINE const ::IR::ExceptionDefSeq *
+IR::ExceptionDefSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDefSeq *
+IR::ExceptionDefSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ExceptionDefSeq_var::operator const ::IR::ExceptionDefSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ExceptionDefSeq_var::operator ::IR::ExceptionDefSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::ExceptionDefSeq_var::operator ::IR::ExceptionDefSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::ExceptionDefSeq_var::operator ::IR::ExceptionDefSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_Object_Manager<IR::ExceptionDef, IR::ExceptionDef_var> 
+IR::ExceptionDefSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::ExceptionDefSeq &
+IR::ExceptionDefSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDefSeq &
+IR::ExceptionDefSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::ExceptionDefSeq *&
+IR::ExceptionDefSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ExceptionDefSeq *
+IR::ExceptionDefSeq_var::_retn (void)
+{
+  ::IR::ExceptionDefSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::ExceptionDefSeq *
+IR::ExceptionDefSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::ExceptionDefSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::ExceptionDefSeq_out::ExceptionDefSeq_out (ExceptionDefSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ExceptionDefSeq_out::ExceptionDefSeq_out (ExceptionDefSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::ExceptionDefSeq_out::ExceptionDefSeq_out (const ::IR::ExceptionDefSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ExceptionDefSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ExceptionDefSeq_out &
+IR::ExceptionDefSeq_out::operator= (const ::IR::ExceptionDefSeq_out &p)
 {
-  this->ptr_ = CORBA_ExceptionDef::_duplicate (p.ptr ());
+  this->ptr_ = ACE_const_cast (ExceptionDefSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ExceptionDef_out &
-CORBA_ExceptionDef_out::operator= (CORBA_ExceptionDef_ptr p)
+ACE_INLINE ::IR::ExceptionDefSeq_out &
+IR::ExceptionDefSeq_out::operator= (ExceptionDefSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDef_out::operator CORBA_ExceptionDef_ptr &() // cast
+IR::ExceptionDefSeq_out::operator ::IR::ExceptionDefSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDef_ptr &
-CORBA_ExceptionDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::ExceptionDefSeq *&
+IR::ExceptionDefSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDef_ptr 
-CORBA_ExceptionDef_out::operator-> (void)
+ACE_INLINE ::IR::ExceptionDefSeq *
+IR::ExceptionDefSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
+ACE_INLINE TAO_Object_Manager<IR::ExceptionDef, IR::ExceptionDef_var> 
+IR::ExceptionDefSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_EXCDESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_EXCDESCRIPTIONSEQ_CI_
 
+  // = Static operations.
+  ACE_INLINE IR::ExceptionDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    IR::ExceptionDescription *retval = 0;
+    ACE_NEW_RETURN (retval, IR::ExceptionDescription[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (IR::ExceptionDescription *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::ExceptionDescription *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::ExceptionDescription *tmp1 = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (this->maximum_);
+      IR::ExceptionDescription * const tmp2 = ACE_reinterpret_cast (IR::ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        IR::ExceptionDescription *tmp = ACE_reinterpret_cast (IR::ExceptionDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::ExceptionDescription *tmp1 = ACE_reinterpret_cast (IR::ExceptionDescription *, this->buffer_);
+    IR::ExceptionDescription * const tmp2 = ACE_reinterpret_cast (IR::ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE IR::ExceptionDescription &
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    IR::ExceptionDescription* tmp = ACE_reinterpret_cast(IR::ExceptionDescription*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const IR::ExceptionDescription &
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    IR::ExceptionDescription * const tmp = ACE_reinterpret_cast (IR::ExceptionDescription* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE IR::ExceptionDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::ExceptionDescription *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::ExceptionDescription*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::ExceptionDescription*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::ExceptionDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::ExceptionDescription * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  IR::_TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  IR::ExceptionDescription *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      IR::ExceptionDescription *tmp = ACE_reinterpret_cast(IR::ExceptionDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_ExcDescriptionSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
 #endif /* end #if !defined */
 
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_EXCDESCRIPTIONSEQ_CI_)
+#define _IR_EXCDESCRIPTIONSEQ_CI_
+
 // *************************************************************
-// Inline operations for class CORBA_ExceptionDescription_var
+// Inline operations for class IR::ExcDescriptionSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ExceptionDescription_var::CORBA_ExceptionDescription_var (void) // default constructor
+IR::ExcDescriptionSeq_var::ExcDescriptionSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ExceptionDescription_var::CORBA_ExceptionDescription_var (CORBA_ExceptionDescription *p)
+IR::ExcDescriptionSeq_var::ExcDescriptionSeq_var (ExcDescriptionSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ExceptionDescription_var::CORBA_ExceptionDescription_var (const CORBA_ExceptionDescription_var &p) // copy constructor
+IR::ExcDescriptionSeq_var::ExcDescriptionSeq_var (const ::IR::ExcDescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ExceptionDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ExcDescriptionSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ExceptionDescription_var::~CORBA_ExceptionDescription_var (void) // destructor
+IR::ExcDescriptionSeq_var::~ExcDescriptionSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDescription_var &
-CORBA_ExceptionDescription_var::operator= (CORBA_ExceptionDescription *p)
+ACE_INLINE IR::ExcDescriptionSeq_var &
+IR::ExcDescriptionSeq_var::operator= (ExcDescriptionSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ExceptionDescription_var &
-CORBA_ExceptionDescription_var::operator= (const CORBA_ExceptionDescription_var &p)
+ACE_INLINE IR::ExcDescriptionSeq_var &
+IR::ExcDescriptionSeq_var::operator= (const ::IR::ExcDescriptionSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ExceptionDescription (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ExcDescriptionSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ExceptionDescription *
-CORBA_ExceptionDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::ExcDescriptionSeq *
+IR::ExcDescriptionSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDescription *
-CORBA_ExceptionDescription_var::operator-> (void)
+ACE_INLINE ::IR::ExcDescriptionSeq *
+IR::ExcDescriptionSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDescription_var::operator const CORBA_ExceptionDescription &() const // cast
+IR::ExcDescriptionSeq_var::operator const ::IR::ExcDescriptionSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDescription_var::operator CORBA_ExceptionDescription &() // cast 
+IR::ExcDescriptionSeq_var::operator ::IR::ExcDescriptionSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDescription_var::operator CORBA_ExceptionDescription &() const// cast 
+IR::ExcDescriptionSeq_var::operator ::IR::ExcDescriptionSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_ExceptionDescription &
-CORBA_ExceptionDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::ExcDescriptionSeq_var::operator ::IR::ExcDescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ExceptionDescription &
+IR::ExcDescriptionSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::ExcDescriptionSeq &
+IR::ExcDescriptionSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDescription &
-CORBA_ExceptionDescription_var::inout (void)
+ACE_INLINE ::IR::ExcDescriptionSeq &
+IR::ExcDescriptionSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ExceptionDescription *&
-CORBA_ExceptionDescription_var::out (void)
+ACE_INLINE ::IR::ExcDescriptionSeq *&
+IR::ExcDescriptionSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDescription *
-CORBA_ExceptionDescription_var::_retn (void)
+ACE_INLINE ::IR::ExcDescriptionSeq *
+IR::ExcDescriptionSeq_var::_retn (void)
 {
-  CORBA_ExceptionDescription *tmp = this->ptr_;
+  ::IR::ExcDescriptionSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ExceptionDescription *
-CORBA_ExceptionDescription_var::ptr (void) const
+ACE_INLINE ::IR::ExcDescriptionSeq *
+IR::ExcDescriptionSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ExceptionDescription_out
+// Inline operations for class IR::ExcDescriptionSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ExceptionDescription_out::CORBA_ExceptionDescription_out (CORBA_ExceptionDescription *&p)
+IR::ExcDescriptionSeq_out::ExcDescriptionSeq_out (ExcDescriptionSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ExceptionDescription_out::CORBA_ExceptionDescription_out (CORBA_ExceptionDescription_var &p) // constructor from _var
+IR::ExcDescriptionSeq_out::ExcDescriptionSeq_out (ExcDescriptionSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -7731,153 +12069,162 @@ CORBA_ExceptionDescription_out::CORBA_ExceptionDescription_out (CORBA_ExceptionD
 }
 
 ACE_INLINE
-CORBA_ExceptionDescription_out::CORBA_ExceptionDescription_out (const CORBA_ExceptionDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ExceptionDescription_out&,p).ptr_)
+IR::ExcDescriptionSeq_out::ExcDescriptionSeq_out (const ::IR::ExcDescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ExcDescriptionSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ExceptionDescription_out &
-CORBA_ExceptionDescription_out::operator= (const CORBA_ExceptionDescription_out &p)
+ACE_INLINE ::IR::ExcDescriptionSeq_out &
+IR::ExcDescriptionSeq_out::operator= (const ::IR::ExcDescriptionSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ExceptionDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ExcDescriptionSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ExceptionDescription_out &
-CORBA_ExceptionDescription_out::operator= (CORBA_ExceptionDescription *p)
+ACE_INLINE ::IR::ExcDescriptionSeq_out &
+IR::ExcDescriptionSeq_out::operator= (ExcDescriptionSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDescription_out::operator CORBA_ExceptionDescription *&() // cast
+IR::ExcDescriptionSeq_out::operator ::IR::ExcDescriptionSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDescription *&
-CORBA_ExceptionDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::ExcDescriptionSeq *&
+IR::ExcDescriptionSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDescription *
-CORBA_ExceptionDescription_out::operator-> (void)
+ACE_INLINE ::IR::ExcDescriptionSeq *
+IR::ExcDescriptionSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
+ACE_INLINE IR::ExceptionDescription &
+IR::ExcDescriptionSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
 ACE_INLINE
-CORBA_AttributeDef::CORBA_AttributeDef (void) // default constructor
+IR::AttributeDef::AttributeDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_AttributeDef::CORBA_AttributeDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::AttributeDef::AttributeDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_AttributeDef::~CORBA_AttributeDef (void) // destructor
+IR::AttributeDef::~AttributeDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_ATTRIBUTEDEF___VAR_CI_)
-#define _CORBA_ATTRIBUTEDEF___VAR_CI_
+#if !defined (_IR_ATTRIBUTEDEF___VAR_CI_)
+#define _IR_ATTRIBUTEDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_AttributeDef_var
+// Inline operations for class IR::AttributeDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_AttributeDef_var::CORBA_AttributeDef_var (void) // default constructor
-  : ptr_ (CORBA_AttributeDef::_nil ())
+IR::AttributeDef_var::AttributeDef_var (void) // default constructor
+  : ptr_ (AttributeDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_AttributeDef_var::CORBA_AttributeDef_var (CORBA_AttributeDef_ptr p)
+IR::AttributeDef_var::AttributeDef_var (AttributeDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_AttributeDef_ptr 
-CORBA_AttributeDef_var::ptr (void) const
+ACE_INLINE ::IR::AttributeDef_ptr
+IR::AttributeDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_AttributeDef_var::CORBA_AttributeDef_var (const CORBA_AttributeDef_var &p) // copy constructor
-  : ptr_ (CORBA_AttributeDef::_duplicate (p.ptr ()))
+IR::AttributeDef_var::AttributeDef_var (const ::IR::AttributeDef_var &p) // copy constructor
+  : ptr_ (AttributeDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_AttributeDef_var::~CORBA_AttributeDef_var (void) // destructor
+IR::AttributeDef_var::~AttributeDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_AttributeDef_var &
-CORBA_AttributeDef_var::operator= (CORBA_AttributeDef_ptr p)
+ACE_INLINE IR::AttributeDef_var &
+IR::AttributeDef_var::operator= (AttributeDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_AttributeDef_var &
-CORBA_AttributeDef_var::operator= (const CORBA_AttributeDef_var &p)
+ACE_INLINE IR::AttributeDef_var &
+IR::AttributeDef_var::operator= (const ::IR::AttributeDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_AttributeDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::AttributeDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_AttributeDef_var::operator const CORBA_AttributeDef_ptr &() const // cast
+IR::AttributeDef_var::operator const ::IR::AttributeDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_AttributeDef_var::operator CORBA_AttributeDef_ptr &() // cast 
+IR::AttributeDef_var::operator ::IR::AttributeDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDef_ptr 
-CORBA_AttributeDef_var::operator-> (void) const
+ACE_INLINE ::IR::AttributeDef_ptr
+IR::AttributeDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDef_ptr
-CORBA_AttributeDef_var::in (void) const
+ACE_INLINE ::IR::AttributeDef_ptr
+IR::AttributeDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDef_ptr &
-CORBA_AttributeDef_var::inout (void)
+ACE_INLINE ::IR::AttributeDef_ptr &
+IR::AttributeDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDef_ptr &
-CORBA_AttributeDef_var::out (void)
+ACE_INLINE ::IR::AttributeDef_ptr &
+IR::AttributeDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_AttributeDef::_nil ();
+  this->ptr_ = ::IR::AttributeDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDef_ptr 
-CORBA_AttributeDef_var::_retn (void)
+ACE_INLINE ::IR::AttributeDef_ptr
+IR::AttributeDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_AttributeDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_AttributeDef::_nil ();
+  ::IR::AttributeDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::AttributeDef::_nil ();
   return val;
 }
 
@@ -7885,68 +12232,68 @@ CORBA_AttributeDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_ATTRIBUTEDEF___OUT_CI_)
-#define _CORBA_ATTRIBUTEDEF___OUT_CI_
+#if !defined (_IR_ATTRIBUTEDEF___OUT_CI_)
+#define _IR_ATTRIBUTEDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_AttributeDef_out
+// Inline operations for class IR::AttributeDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_AttributeDef_out::CORBA_AttributeDef_out (CORBA_AttributeDef_ptr &p)
+IR::AttributeDef_out::AttributeDef_out (AttributeDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_AttributeDef::_nil ();
+  this->ptr_ = ::IR::AttributeDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_AttributeDef_out::CORBA_AttributeDef_out (CORBA_AttributeDef_var &p) // constructor from _var
+IR::AttributeDef_out::AttributeDef_out (AttributeDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_AttributeDef::_nil ();
+  this->ptr_ = ::IR::AttributeDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_AttributeDef_out::CORBA_AttributeDef_out (const CORBA_AttributeDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_AttributeDef_out&,p).ptr_)
+IR::AttributeDef_out::AttributeDef_out (const ::IR::AttributeDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (AttributeDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_AttributeDef_out &
-CORBA_AttributeDef_out::operator= (const CORBA_AttributeDef_out &p)
+ACE_INLINE ::IR::AttributeDef_out &
+IR::AttributeDef_out::operator= (const ::IR::AttributeDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_AttributeDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (AttributeDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_AttributeDef_out &
-CORBA_AttributeDef_out::operator= (const CORBA_AttributeDef_var &p)
+ACE_INLINE IR::AttributeDef_out &
+IR::AttributeDef_out::operator= (const ::IR::AttributeDef_var &p)
 {
-  this->ptr_ = CORBA_AttributeDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::AttributeDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_AttributeDef_out &
-CORBA_AttributeDef_out::operator= (CORBA_AttributeDef_ptr p)
+ACE_INLINE IR::AttributeDef_out &
+IR::AttributeDef_out::operator= (AttributeDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_AttributeDef_out::operator CORBA_AttributeDef_ptr &() // cast
+IR::AttributeDef_out::operator ::IR::AttributeDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDef_ptr &
-CORBA_AttributeDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::AttributeDef_ptr &
+IR::AttributeDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDef_ptr 
-CORBA_AttributeDef_out::operator-> (void)
+ACE_INLINE ::IR::AttributeDef_ptr
+IR::AttributeDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -7955,134 +12302,138 @@ CORBA_AttributeDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA_AttributeDescription_var
+// Inline operations for class IR::AttributeDescription_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_AttributeDescription_var::CORBA_AttributeDescription_var (void) // default constructor
+IR::AttributeDescription_var::AttributeDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_AttributeDescription_var::CORBA_AttributeDescription_var (CORBA_AttributeDescription *p)
+IR::AttributeDescription_var::AttributeDescription_var (AttributeDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_AttributeDescription_var::CORBA_AttributeDescription_var (const CORBA_AttributeDescription_var &p) // copy constructor
+IR::AttributeDescription_var::AttributeDescription_var (const ::IR::AttributeDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_AttributeDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::AttributeDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_AttributeDescription_var::~CORBA_AttributeDescription_var (void) // destructor
+IR::AttributeDescription_var::~AttributeDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDescription_var &
-CORBA_AttributeDescription_var::operator= (CORBA_AttributeDescription *p)
+ACE_INLINE IR::AttributeDescription_var &
+IR::AttributeDescription_var::operator= (AttributeDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_AttributeDescription_var &
-CORBA_AttributeDescription_var::operator= (const CORBA_AttributeDescription_var &p)
+ACE_INLINE ::IR::AttributeDescription_var &
+IR::AttributeDescription_var::operator= (const ::IR::AttributeDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_AttributeDescription (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::AttributeDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_AttributeDescription *
-CORBA_AttributeDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::AttributeDescription *
+IR::AttributeDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDescription *
-CORBA_AttributeDescription_var::operator-> (void)
+ACE_INLINE ::IR::AttributeDescription *
+IR::AttributeDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_AttributeDescription_var::operator const CORBA_AttributeDescription &() const // cast
+ACE_INLINE
+IR::AttributeDescription_var::operator const ::IR::AttributeDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_AttributeDescription_var::operator CORBA_AttributeDescription &() // cast 
+ACE_INLINE
+IR::AttributeDescription_var::operator ::IR::AttributeDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_AttributeDescription_var::operator CORBA_AttributeDescription &() const// cast 
+ACE_INLINE
+IR::AttributeDescription_var::operator ::IR::AttributeDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_AttributeDescription &
-CORBA_AttributeDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::AttributeDescription_var::operator ::IR::AttributeDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::AttributeDescription &
+IR::AttributeDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDescription &
-CORBA_AttributeDescription_var::inout (void)
+ACE_INLINE ::IR::AttributeDescription &
+IR::AttributeDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_AttributeDescription *&
-CORBA_AttributeDescription_var::out (void)
+ACE_INLINE ::IR::AttributeDescription *&
+IR::AttributeDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDescription *
-CORBA_AttributeDescription_var::_retn (void)
+ACE_INLINE ::IR::AttributeDescription *
+IR::AttributeDescription_var::_retn (void)
 {
-  CORBA_AttributeDescription *tmp = this->ptr_;
+  ::IR::AttributeDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_AttributeDescription *
-CORBA_AttributeDescription_var::ptr (void) const
+ACE_INLINE ::IR::AttributeDescription *
+IR::AttributeDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_AttributeDescription_out
+// Inline operations for class IR::AttributeDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_AttributeDescription_out::CORBA_AttributeDescription_out (CORBA_AttributeDescription *&p)
+IR::AttributeDescription_out::AttributeDescription_out (::IR::AttributeDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_AttributeDescription_out::CORBA_AttributeDescription_out (CORBA_AttributeDescription_var &p) // constructor from _var
+IR::AttributeDescription_out::AttributeDescription_out (AttributeDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -8090,171 +12441,175 @@ CORBA_AttributeDescription_out::CORBA_AttributeDescription_out (CORBA_AttributeD
 }
 
 ACE_INLINE
-CORBA_AttributeDescription_out::CORBA_AttributeDescription_out (const CORBA_AttributeDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_AttributeDescription_out&,p).ptr_)
+IR::AttributeDescription_out::AttributeDescription_out (const ::IR::AttributeDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (AttributeDescription_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_AttributeDescription_out &
-CORBA_AttributeDescription_out::operator= (const CORBA_AttributeDescription_out &p)
+ACE_INLINE IR::AttributeDescription_out &
+IR::AttributeDescription_out::operator= (const ::IR::AttributeDescription_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_AttributeDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (AttributeDescription_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_AttributeDescription_out &
-CORBA_AttributeDescription_out::operator= (CORBA_AttributeDescription *p)
+ACE_INLINE IR::AttributeDescription_out &
+IR::AttributeDescription_out::operator= (AttributeDescription *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_AttributeDescription_out::operator CORBA_AttributeDescription *&() // cast
+IR::AttributeDescription_out::operator ::IR::AttributeDescription *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDescription *&
-CORBA_AttributeDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::AttributeDescription *&
+IR::AttributeDescription_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDescription *
-CORBA_AttributeDescription_out::operator-> (void)
+ACE_INLINE ::IR::AttributeDescription *
+IR::AttributeDescription_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ParameterDescription_var
+// Inline operations for class IR::ParameterDescription_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ParameterDescription_var::CORBA_ParameterDescription_var (void) // default constructor
+IR::ParameterDescription_var::ParameterDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ParameterDescription_var::CORBA_ParameterDescription_var (CORBA_ParameterDescription *p)
+IR::ParameterDescription_var::ParameterDescription_var (ParameterDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ParameterDescription_var::CORBA_ParameterDescription_var (const CORBA_ParameterDescription_var &p) // copy constructor
+IR::ParameterDescription_var::ParameterDescription_var (const ::IR::ParameterDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ParameterDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ParameterDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ParameterDescription_var::~CORBA_ParameterDescription_var (void) // destructor
+IR::ParameterDescription_var::~ParameterDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ParameterDescription_var &
-CORBA_ParameterDescription_var::operator= (CORBA_ParameterDescription *p)
+ACE_INLINE IR::ParameterDescription_var &
+IR::ParameterDescription_var::operator= (ParameterDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ParameterDescription_var &
-CORBA_ParameterDescription_var::operator= (const CORBA_ParameterDescription_var &p)
+ACE_INLINE ::IR::ParameterDescription_var &
+IR::ParameterDescription_var::operator= (const ::IR::ParameterDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ParameterDescription (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ParameterDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ParameterDescription *
-CORBA_ParameterDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::ParameterDescription *
+IR::ParameterDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ParameterDescription *
-CORBA_ParameterDescription_var::operator-> (void)
+ACE_INLINE ::IR::ParameterDescription *
+IR::ParameterDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ParameterDescription_var::operator const CORBA_ParameterDescription &() const // cast
+ACE_INLINE
+IR::ParameterDescription_var::operator const ::IR::ParameterDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ParameterDescription_var::operator CORBA_ParameterDescription &() // cast 
+ACE_INLINE
+IR::ParameterDescription_var::operator ::IR::ParameterDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ParameterDescription_var::operator CORBA_ParameterDescription &() const// cast 
+ACE_INLINE
+IR::ParameterDescription_var::operator ::IR::ParameterDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_ParameterDescription &
-CORBA_ParameterDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::ParameterDescription_var::operator ::IR::ParameterDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::ParameterDescription &
+IR::ParameterDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ParameterDescription &
-CORBA_ParameterDescription_var::inout (void)
+ACE_INLINE ::IR::ParameterDescription &
+IR::ParameterDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ParameterDescription *&
-CORBA_ParameterDescription_var::out (void)
+ACE_INLINE ::IR::ParameterDescription *&
+IR::ParameterDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ParameterDescription *
-CORBA_ParameterDescription_var::_retn (void)
+ACE_INLINE ::IR::ParameterDescription *
+IR::ParameterDescription_var::_retn (void)
 {
-  CORBA_ParameterDescription *tmp = this->ptr_;
+  ::IR::ParameterDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ParameterDescription *
-CORBA_ParameterDescription_var::ptr (void) const
+ACE_INLINE ::IR::ParameterDescription *
+IR::ParameterDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ParameterDescription_out
+// Inline operations for class IR::ParameterDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ParameterDescription_out::CORBA_ParameterDescription_out (CORBA_ParameterDescription *&p)
+IR::ParameterDescription_out::ParameterDescription_out (::IR::ParameterDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ParameterDescription_out::CORBA_ParameterDescription_out (CORBA_ParameterDescription_var &p) // constructor from _var
+IR::ParameterDescription_out::ParameterDescription_out (ParameterDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -8262,38 +12617,38 @@ CORBA_ParameterDescription_out::CORBA_ParameterDescription_out (CORBA_ParameterD
 }
 
 ACE_INLINE
-CORBA_ParameterDescription_out::CORBA_ParameterDescription_out (const CORBA_ParameterDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ParameterDescription_out&,p).ptr_)
+IR::ParameterDescription_out::ParameterDescription_out (const ::IR::ParameterDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ParameterDescription_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ParameterDescription_out &
-CORBA_ParameterDescription_out::operator= (const CORBA_ParameterDescription_out &p)
+ACE_INLINE IR::ParameterDescription_out &
+IR::ParameterDescription_out::operator= (const ::IR::ParameterDescription_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ParameterDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ParameterDescription_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ParameterDescription_out &
-CORBA_ParameterDescription_out::operator= (CORBA_ParameterDescription *p)
+ACE_INLINE IR::ParameterDescription_out &
+IR::ParameterDescription_out::operator= (ParameterDescription *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ParameterDescription_out::operator CORBA_ParameterDescription *&() // cast
+IR::ParameterDescription_out::operator ::IR::ParameterDescription *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ParameterDescription *&
-CORBA_ParameterDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::ParameterDescription *&
+IR::ParameterDescription_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ParameterDescription *
-CORBA_ParameterDescription_out::operator-> (void)
+ACE_INLINE ::IR::ParameterDescription *
+IR::ParameterDescription_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -8301,63 +12656,68 @@ CORBA_ParameterDescription_out::operator-> (void)
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CI_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_PARDESCRIPTIONSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_PARDESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_PARDESCRIPTIONSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE CORBA_ParameterDescription *
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE IR::ParameterDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    CORBA_ParameterDescription *retval = 0;
-    ACE_NEW_RETURN (retval,
-                    CORBA_ParameterDescription[size],
-		    0);
+    IR::ParameterDescription *retval = 0;
+    ACE_NEW_RETURN (retval, IR::ParameterDescription[size], 0);
     return retval;
   }
   
-  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (CORBA_ParameterDescription *buffer)
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (IR::ParameterDescription *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (void) // Default constructor.
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_ParameterDescription *data,
+    IR::ParameterDescription *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq (const _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_ParameterDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (this->maximum_);
-    CORBA_ParameterDescription * const tmp2 = ACE_reinterpret_cast (CORBA_ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    this->buffer_ = tmp1;
+    if (rhs.buffer_ != 0)
+    {
+      IR::ParameterDescription *tmp1 = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (this->maximum_);
+      IR::ParameterDescription * const tmp2 = ACE_reinterpret_cast (IR::ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq &rhs)
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq &
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_ParDescriptionSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -8368,18 +12728,18 @@ CORBA_ParameterDescription_out::operator-> (void)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        CORBA_ParameterDescription *tmp = ACE_reinterpret_cast (CORBA_ParameterDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (rhs.maximum_);
+        IR::ParameterDescription *tmp = ACE_reinterpret_cast (IR::ParameterDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_ParameterDescription *tmp1 = ACE_reinterpret_cast (CORBA_ParameterDescription *, this->buffer_);
-    CORBA_ParameterDescription * const tmp2 = ACE_reinterpret_cast (CORBA_ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
+    IR::ParameterDescription *tmp1 = ACE_reinterpret_cast (IR::ParameterDescription *, this->buffer_);
+    IR::ParameterDescription * const tmp2 = ACE_reinterpret_cast (IR::ParameterDescription * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -8388,41 +12748,41 @@ CORBA_ParameterDescription_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE CORBA_ParameterDescription &
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE IR::ParameterDescription &
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_ParameterDescription* tmp = ACE_reinterpret_cast(CORBA_ParameterDescription*,this->buffer_);
+    IR::ParameterDescription* tmp = ACE_reinterpret_cast(IR::ParameterDescription*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const CORBA_ParameterDescription &
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const IR::ParameterDescription &
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_ParameterDescription * const tmp = ACE_reinterpret_cast (CORBA_ParameterDescription* ACE_CAST_CONST, this->buffer_);
+    IR::ParameterDescription * const tmp = ACE_reinterpret_cast (IR::ParameterDescription* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE CORBA_ParameterDescription *
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::ParameterDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_ParameterDescription *result = 0;
+    IR::ParameterDescription *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::allocbuf (this->length_);
+        result = _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::allocbuf (this->length_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_ParameterDescription*, this->buffer_);
+        result = ACE_reinterpret_cast (IR::ParameterDescription*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -8431,7 +12791,7 @@ CORBA_ParameterDescription_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_ParameterDescription*,this->buffer_);
+        result = ACE_reinterpret_cast(IR::ParameterDescription*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -8441,24 +12801,24 @@ CORBA_ParameterDescription_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const CORBA_ParameterDescription *
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::get_buffer (void) const
+  ACE_INLINE const IR::ParameterDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_ParameterDescription * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::ParameterDescription * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::replace (CORBA::ULong max,
+  IR::_TAO_Unbounded_Sequence_IR_ParDescriptionSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  CORBA_ParameterDescription *data,
+  IR::ParameterDescription *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      CORBA_ParameterDescription *tmp = ACE_reinterpret_cast(CORBA_ParameterDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_CORBA_ParDescriptionSeq::freebuf (tmp);
+      IR::ParameterDescription *tmp = ACE_reinterpret_cast(IR::ParameterDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_ParDescriptionSeq::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -8469,144 +12829,148 @@ CORBA_ParameterDescription_out::operator-> (void)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_PARDESCRIPTIONSEQ_CI_)
-#define _CORBA_PARDESCRIPTIONSEQ_CI_
+#if !defined (_IR_PARDESCRIPTIONSEQ_CI_)
+#define _IR_PARDESCRIPTIONSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ParDescriptionSeq_var
+// Inline operations for class IR::ParDescriptionSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ParDescriptionSeq_var::CORBA_ParDescriptionSeq_var (void) // default constructor
+IR::ParDescriptionSeq_var::ParDescriptionSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ParDescriptionSeq_var::CORBA_ParDescriptionSeq_var (CORBA_ParDescriptionSeq *p)
+IR::ParDescriptionSeq_var::ParDescriptionSeq_var (ParDescriptionSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ParDescriptionSeq_var::CORBA_ParDescriptionSeq_var (const CORBA_ParDescriptionSeq_var &p) // copy constructor
+IR::ParDescriptionSeq_var::ParDescriptionSeq_var (const ::IR::ParDescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ParDescriptionSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ParDescriptionSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ParDescriptionSeq_var::~CORBA_ParDescriptionSeq_var (void) // destructor
+IR::ParDescriptionSeq_var::~ParDescriptionSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ParDescriptionSeq_var &
-CORBA_ParDescriptionSeq_var::operator= (CORBA_ParDescriptionSeq *p)
+ACE_INLINE IR::ParDescriptionSeq_var &
+IR::ParDescriptionSeq_var::operator= (ParDescriptionSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ParDescriptionSeq_var &
-CORBA_ParDescriptionSeq_var::operator= (const CORBA_ParDescriptionSeq_var &p) // deep copy
+ACE_INLINE IR::ParDescriptionSeq_var &
+IR::ParDescriptionSeq_var::operator= (const ::IR::ParDescriptionSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ParDescriptionSeq (*p.ptr_),
-	            *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ParDescriptionSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ParDescriptionSeq *
-CORBA_ParDescriptionSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::ParDescriptionSeq *
+IR::ParDescriptionSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ParDescriptionSeq *
-CORBA_ParDescriptionSeq_var::operator-> (void)
+ACE_INLINE ::IR::ParDescriptionSeq *
+IR::ParDescriptionSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ParDescriptionSeq_var::operator const CORBA_ParDescriptionSeq &() const // cast
+IR::ParDescriptionSeq_var::operator const ::IR::ParDescriptionSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ParDescriptionSeq_var::operator CORBA_ParDescriptionSeq &() // cast 
+IR::ParDescriptionSeq_var::operator ::IR::ParDescriptionSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ParDescriptionSeq_var::operator CORBA_ParDescriptionSeq &() const// cast 
+IR::ParDescriptionSeq_var::operator ::IR::ParDescriptionSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ParameterDescription &
-CORBA_ParDescriptionSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::ParDescriptionSeq_var::operator ::IR::ParDescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ParameterDescription &
+IR::ParDescriptionSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_ParDescriptionSeq &
-CORBA_ParDescriptionSeq_var::in (void) const
+ACE_INLINE const ::IR::ParDescriptionSeq &
+IR::ParDescriptionSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ParDescriptionSeq &
-CORBA_ParDescriptionSeq_var::inout (void)
+ACE_INLINE ::IR::ParDescriptionSeq &
+IR::ParDescriptionSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ParDescriptionSeq *&
-CORBA_ParDescriptionSeq_var::out (void)
+ACE_INLINE ::IR::ParDescriptionSeq *&
+IR::ParDescriptionSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ParDescriptionSeq *
-CORBA_ParDescriptionSeq_var::_retn (void)
+ACE_INLINE ::IR::ParDescriptionSeq *
+IR::ParDescriptionSeq_var::_retn (void)
 {
-  CORBA_ParDescriptionSeq *tmp = this->ptr_;
+  ::IR::ParDescriptionSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ParDescriptionSeq *
-CORBA_ParDescriptionSeq_var::ptr (void) const
+ACE_INLINE ::IR::ParDescriptionSeq *
+IR::ParDescriptionSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ParDescriptionSeq_out
+// Inline operations for class IR::ParDescriptionSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ParDescriptionSeq_out::CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSeq *&p)
+IR::ParDescriptionSeq_out::ParDescriptionSeq_out (ParDescriptionSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ParDescriptionSeq_out::CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSeq_var &p) // constructor from _var
+IR::ParDescriptionSeq_out::ParDescriptionSeq_out (ParDescriptionSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -8614,44 +12978,44 @@ CORBA_ParDescriptionSeq_out::CORBA_ParDescriptionSeq_out (CORBA_ParDescriptionSe
 }
 
 ACE_INLINE
-CORBA_ParDescriptionSeq_out::CORBA_ParDescriptionSeq_out (const CORBA_ParDescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ParDescriptionSeq_out&,p).ptr_)
+IR::ParDescriptionSeq_out::ParDescriptionSeq_out (const ::IR::ParDescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ParDescriptionSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ParDescriptionSeq_out &
-CORBA_ParDescriptionSeq_out::operator= (const CORBA_ParDescriptionSeq_out &p)
+ACE_INLINE ::IR::ParDescriptionSeq_out &
+IR::ParDescriptionSeq_out::operator= (const ::IR::ParDescriptionSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ParDescriptionSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ParDescriptionSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ParDescriptionSeq_out &
-CORBA_ParDescriptionSeq_out::operator= (CORBA_ParDescriptionSeq *p)
+ACE_INLINE ::IR::ParDescriptionSeq_out &
+IR::ParDescriptionSeq_out::operator= (ParDescriptionSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ParDescriptionSeq_out::operator CORBA_ParDescriptionSeq *&() // cast
+IR::ParDescriptionSeq_out::operator ::IR::ParDescriptionSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ParDescriptionSeq *&
-CORBA_ParDescriptionSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::ParDescriptionSeq *&
+IR::ParDescriptionSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ParDescriptionSeq *
-CORBA_ParDescriptionSeq_out::operator-> (void)
+ACE_INLINE ::IR::ParDescriptionSeq *
+IR::ParDescriptionSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ParameterDescription &
-CORBA_ParDescriptionSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE IR::ParameterDescription &
+IR::ParDescriptionSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -8660,144 +13024,148 @@ CORBA_ParDescriptionSeq_out::operator[] (CORBA::ULong index)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_CONTEXTIDSEQ_CI_)
-#define _CORBA_CONTEXTIDSEQ_CI_
+#if !defined (_IR_CONTEXTIDSEQ_CI_)
+#define _IR_CONTEXTIDSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ContextIdSeq_var
+// Inline operations for class IR::ContextIdSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ContextIdSeq_var::CORBA_ContextIdSeq_var (void) // default constructor
+IR::ContextIdSeq_var::ContextIdSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ContextIdSeq_var::CORBA_ContextIdSeq_var (CORBA_ContextIdSeq *p)
+IR::ContextIdSeq_var::ContextIdSeq_var (ContextIdSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ContextIdSeq_var::CORBA_ContextIdSeq_var (const CORBA_ContextIdSeq_var &p) // copy constructor
+IR::ContextIdSeq_var::ContextIdSeq_var (const ::IR::ContextIdSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ContextIdSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ContextIdSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ContextIdSeq_var::~CORBA_ContextIdSeq_var (void) // destructor
+IR::ContextIdSeq_var::~ContextIdSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ContextIdSeq_var &
-CORBA_ContextIdSeq_var::operator= (CORBA_ContextIdSeq *p)
+ACE_INLINE IR::ContextIdSeq_var &
+IR::ContextIdSeq_var::operator= (ContextIdSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ContextIdSeq_var &
-CORBA_ContextIdSeq_var::operator= (const CORBA_ContextIdSeq_var &p) // deep copy
+ACE_INLINE IR::ContextIdSeq_var &
+IR::ContextIdSeq_var::operator= (const ::IR::ContextIdSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ContextIdSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ContextIdSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ContextIdSeq *
-CORBA_ContextIdSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::ContextIdSeq *
+IR::ContextIdSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ContextIdSeq *
-CORBA_ContextIdSeq_var::operator-> (void)
+ACE_INLINE ::IR::ContextIdSeq *
+IR::ContextIdSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ContextIdSeq_var::operator const CORBA_ContextIdSeq &() const // cast
+IR::ContextIdSeq_var::operator const ::IR::ContextIdSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ContextIdSeq_var::operator CORBA_ContextIdSeq &() // cast 
+IR::ContextIdSeq_var::operator ::IR::ContextIdSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ContextIdSeq_var::operator CORBA_ContextIdSeq &() const// cast 
+IR::ContextIdSeq_var::operator ::IR::ContextIdSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
+// variable-size types only
+ACE_INLINE
+IR::ContextIdSeq_var::operator ::IR::ContextIdSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
 ACE_INLINE TAO_SeqElem_String_Manager 
-CORBA_ContextIdSeq_var::operator[] (CORBA::ULong index)
+IR::ContextIdSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_ContextIdSeq &
-CORBA_ContextIdSeq_var::in (void) const
+ACE_INLINE const ::IR::ContextIdSeq &
+IR::ContextIdSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ContextIdSeq &
-CORBA_ContextIdSeq_var::inout (void)
+ACE_INLINE ::IR::ContextIdSeq &
+IR::ContextIdSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ContextIdSeq *&
-CORBA_ContextIdSeq_var::out (void)
+ACE_INLINE ::IR::ContextIdSeq *&
+IR::ContextIdSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ContextIdSeq *
-CORBA_ContextIdSeq_var::_retn (void)
+ACE_INLINE ::IR::ContextIdSeq *
+IR::ContextIdSeq_var::_retn (void)
 {
-  CORBA_ContextIdSeq *tmp = this->ptr_;
+  ::IR::ContextIdSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ContextIdSeq *
-CORBA_ContextIdSeq_var::ptr (void) const
+ACE_INLINE ::IR::ContextIdSeq *
+IR::ContextIdSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ContextIdSeq_out
+// Inline operations for class IR::ContextIdSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ContextIdSeq_out::CORBA_ContextIdSeq_out (CORBA_ContextIdSeq *&p)
+IR::ContextIdSeq_out::ContextIdSeq_out (ContextIdSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ContextIdSeq_out::CORBA_ContextIdSeq_out (CORBA_ContextIdSeq_var &p) // constructor from _var
+IR::ContextIdSeq_out::ContextIdSeq_out (ContextIdSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -8805,44 +13173,602 @@ CORBA_ContextIdSeq_out::CORBA_ContextIdSeq_out (CORBA_ContextIdSeq_var &p) // co
 }
 
 ACE_INLINE
-CORBA_ContextIdSeq_out::CORBA_ContextIdSeq_out (const CORBA_ContextIdSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ContextIdSeq_out&,p).ptr_)
+IR::ContextIdSeq_out::ContextIdSeq_out (const ::IR::ContextIdSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ContextIdSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ContextIdSeq_out &
-CORBA_ContextIdSeq_out::operator= (const CORBA_ContextIdSeq_out &p)
+ACE_INLINE ::IR::ContextIdSeq_out &
+IR::ContextIdSeq_out::operator= (const ::IR::ContextIdSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ContextIdSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ContextIdSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ContextIdSeq_out &
-CORBA_ContextIdSeq_out::operator= (CORBA_ContextIdSeq *p)
+ACE_INLINE ::IR::ContextIdSeq_out &
+IR::ContextIdSeq_out::operator= (ContextIdSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ContextIdSeq_out::operator CORBA_ContextIdSeq *&() // cast
+IR::ContextIdSeq_out::operator ::IR::ContextIdSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ContextIdSeq *&
-CORBA_ContextIdSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::ContextIdSeq *&
+IR::ContextIdSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ContextIdSeq *
-CORBA_ContextIdSeq_out::operator-> (void)
+ACE_INLINE ::IR::ContextIdSeq *
+IR::ContextIdSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE TAO_SeqElem_String_Manager 
-CORBA_ContextIdSeq_out::operator[] (CORBA::ULong index)
+IR::ContextIdSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
+ACE_INLINE
+IR::OperationDef::OperationDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::OperationDef::OperationDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::OperationDef::~OperationDef (void) // destructor
+{}
+
+
+#if !defined (_IR_OPERATIONDEF___VAR_CI_)
+#define _IR_OPERATIONDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::OperationDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::OperationDef_var::OperationDef_var (void) // default constructor
+  : ptr_ (OperationDef::_nil ())
+{}
+
+ACE_INLINE
+IR::OperationDef_var::OperationDef_var (OperationDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::OperationDef_ptr
+IR::OperationDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::OperationDef_var::OperationDef_var (const ::IR::OperationDef_var &p) // copy constructor
+  : ptr_ (OperationDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::OperationDef_var::~OperationDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::OperationDef_var &
+IR::OperationDef_var::operator= (OperationDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::OperationDef_var &
+IR::OperationDef_var::operator= (const ::IR::OperationDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::OperationDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::OperationDef_var::operator const ::IR::OperationDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::OperationDef_var::operator ::IR::OperationDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDef_ptr
+IR::OperationDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDef_ptr
+IR::OperationDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDef_ptr &
+IR::OperationDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDef_ptr &
+IR::OperationDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::OperationDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDef_ptr
+IR::OperationDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::OperationDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::OperationDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_OPERATIONDEF___OUT_CI_)
+#define _IR_OPERATIONDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::OperationDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::OperationDef_out::OperationDef_out (OperationDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::OperationDef::_nil ();
+}
+
+ACE_INLINE
+IR::OperationDef_out::OperationDef_out (OperationDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::OperationDef::_nil ();
+}
+
+ACE_INLINE
+IR::OperationDef_out::OperationDef_out (const ::IR::OperationDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (OperationDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::OperationDef_out &
+IR::OperationDef_out::operator= (const ::IR::OperationDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (OperationDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::OperationDef_out &
+IR::OperationDef_out::operator= (const ::IR::OperationDef_var &p)
+{
+  this->ptr_ = ::IR::OperationDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::OperationDef_out &
+IR::OperationDef_out::operator= (OperationDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::OperationDef_out::operator ::IR::OperationDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDef_ptr &
+IR::OperationDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDef_ptr
+IR::OperationDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class IR::OperationDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::OperationDescription_var::OperationDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::OperationDescription_var::OperationDescription_var (OperationDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::OperationDescription_var::OperationDescription_var (const ::IR::OperationDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::OperationDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::OperationDescription_var::~OperationDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::OperationDescription_var &
+IR::OperationDescription_var::operator= (OperationDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::OperationDescription_var &
+IR::OperationDescription_var::operator= (const ::IR::OperationDescription_var &p)
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::OperationDescription (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::OperationDescription *
+IR::OperationDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDescription *
+IR::OperationDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::OperationDescription_var::operator const ::IR::OperationDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::OperationDescription_var::operator ::IR::OperationDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::OperationDescription_var::operator ::IR::OperationDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::OperationDescription_var::operator ::IR::OperationDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::OperationDescription &
+IR::OperationDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDescription &
+IR::OperationDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::OperationDescription *&
+IR::OperationDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDescription *
+IR::OperationDescription_var::_retn (void)
+{
+  ::IR::OperationDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::OperationDescription *
+IR::OperationDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::OperationDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::OperationDescription_out::OperationDescription_out (::IR::OperationDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::OperationDescription_out::OperationDescription_out (OperationDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::OperationDescription_out::OperationDescription_out (const ::IR::OperationDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (OperationDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::OperationDescription_out &
+IR::OperationDescription_out::operator= (const ::IR::OperationDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (OperationDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::OperationDescription_out &
+IR::OperationDescription_out::operator= (OperationDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::OperationDescription_out::operator ::IR::OperationDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDescription *&
+IR::OperationDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::OperationDescription *
+IR::OperationDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#if !defined (_IR_REPOSITORYIDSEQ_CI_)
+#define _IR_REPOSITORYIDSEQ_CI_
+
+// *************************************************************
+// Inline operations for class IR::RepositoryIdSeq_var
+// *************************************************************
+
+ACE_INLINE
+IR::RepositoryIdSeq_var::RepositoryIdSeq_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::RepositoryIdSeq_var::RepositoryIdSeq_var (RepositoryIdSeq *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::RepositoryIdSeq_var::RepositoryIdSeq_var (const ::IR::RepositoryIdSeq_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::RepositoryIdSeq (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::RepositoryIdSeq_var::~RepositoryIdSeq_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::RepositoryIdSeq_var &
+IR::RepositoryIdSeq_var::operator= (RepositoryIdSeq *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::RepositoryIdSeq_var &
+IR::RepositoryIdSeq_var::operator= (const ::IR::RepositoryIdSeq_var &p) // deep copy
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::RepositoryIdSeq (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::RepositoryIdSeq_var::operator const ::IR::RepositoryIdSeq &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::RepositoryIdSeq_var::operator ::IR::RepositoryIdSeq &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE 
+IR::RepositoryIdSeq_var::operator ::IR::RepositoryIdSeq &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::RepositoryIdSeq_var::operator ::IR::RepositoryIdSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager 
+IR::RepositoryIdSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::RepositoryIdSeq &
+IR::RepositoryIdSeq_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq &
+IR::RepositoryIdSeq_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::RepositoryIdSeq *&
+IR::RepositoryIdSeq_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_var::_retn (void)
+{
+  ::IR::RepositoryIdSeq *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::RepositoryIdSeq_out
+// *************************************************************
+
+ACE_INLINE
+IR::RepositoryIdSeq_out::RepositoryIdSeq_out (RepositoryIdSeq *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::RepositoryIdSeq_out::RepositoryIdSeq_out (RepositoryIdSeq_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::RepositoryIdSeq_out::RepositoryIdSeq_out (const ::IR::RepositoryIdSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (RepositoryIdSeq_out&, p).ptr_)
+{}
+
+ACE_INLINE ::IR::RepositoryIdSeq_out &
+IR::RepositoryIdSeq_out::operator= (const ::IR::RepositoryIdSeq_out &p)
+{
+  this->ptr_ = ACE_const_cast (RepositoryIdSeq_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq_out &
+IR::RepositoryIdSeq_out::operator= (RepositoryIdSeq *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::RepositoryIdSeq_out::operator ::IR::RepositoryIdSeq *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *&
+IR::RepositoryIdSeq_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::RepositoryIdSeq *
+IR::RepositoryIdSeq_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE TAO_SeqElem_String_Manager 
+IR::RepositoryIdSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -8853,122 +13779,133 @@ CORBA_ContextIdSeq_out::operator[] (CORBA::ULong index)
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CI_)
-#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_CORBA_EXCEPTIONDEFSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_OPDESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_OPDESCRIPTIONSEQ_CI_
 
-  ACE_INLINE CORBA_ExceptionDef **
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (CORBA::ULong nelems)
+  // = Static operations.
+  ACE_INLINE IR::OperationDescription *
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
   {
-    CORBA_ExceptionDef **buf = 0;
-    
-    ACE_NEW_RETURN (buf, CORBA_ExceptionDef*[nelems], 0);
-    
-    for (CORBA::ULong i = 0; i < nelems; i++)
-      buf[i] = CORBA_ExceptionDef::_nil ();
-    
-    return buf;
+    IR::OperationDescription *retval = 0;
+    ACE_NEW_RETURN (retval, IR::OperationDescription[size], 0);
+    return retval;
   }
   
-  ACE_INLINE void 
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (CORBA_ExceptionDef **buffer)
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (IR::OperationDescription *buffer)
+  // Free the sequence.
   {
-    if (buffer == 0)
-      return;
-    delete[] buffer;
+    delete [] buffer;
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (void)
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum)
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_ExceptionDef* *value,
+    IR::OperationDescription *data,
     CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, value, release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::_TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq(const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq (const _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &rhs)
+  // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_ExceptionDef **tmp1 = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (this->maximum_);
-    CORBA_ExceptionDef ** const tmp2 = ACE_reinterpret_cast (CORBA_ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = CORBA_ExceptionDef::_duplicate (tmp2[i]);
-    
-    this->buffer_ = tmp1;
+    if (rhs.buffer_ != 0)
+    {
+      IR::OperationDescription *tmp1 = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (this->maximum_);
+      IR::OperationDescription * const tmp2 = ACE_reinterpret_cast (IR::OperationDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator= (const _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq &rhs)
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq &
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_OpDescriptionSeq &rhs)
+  // Assignment operator.
   {
     if (this == &rhs)
       return *this;
     
     if (this->release_)
     {
-      CORBA_ExceptionDef **tmp = ACE_reinterpret_cast (CORBA_ExceptionDef **, this->buffer_);
-      
-      for (CORBA::ULong i = 0; i < this->length_; ++i)
-      {
-        CORBA::release (tmp[i]);
-        tmp[i] = CORBA_ExceptionDef::_nil ();
-      }
       if (this->maximum_ < rhs.maximum_)
       {
-        _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (rhs.maximum_);
+        // free the old buffer
+        IR::OperationDescription *tmp = ACE_reinterpret_cast (IR::OperationDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_ExceptionDef **tmp1 = ACE_reinterpret_cast (CORBA_ExceptionDef **, this->buffer_);
-    CORBA_ExceptionDef ** const tmp2 = ACE_reinterpret_cast (CORBA_ExceptionDef ** ACE_CAST_CONST, rhs.buffer_);
+    IR::OperationDescription *tmp1 = ACE_reinterpret_cast (IR::OperationDescription *, this->buffer_);
+    IR::OperationDescription * const tmp2 = ACE_reinterpret_cast (IR::OperationDescription * ACE_CAST_CONST, rhs.buffer_);
     
-    for (CORBA::ULong i = 0; i < rhs.length_; ++i)
-      tmp1[i] = CORBA_ExceptionDef::_duplicate (tmp2[i]);
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
     
     return *this;
   }
   
-  ACE_INLINE TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var>
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::operator[] (CORBA::ULong index) const
-  // read-write accessor
+  // = Accessors.
+  ACE_INLINE IR::OperationDescription &
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::operator[] (CORBA::ULong i)
+  // operator []
   {
-    ACE_ASSERT (index < this->maximum_);
-    CORBA_ExceptionDef ** const tmp = ACE_reinterpret_cast (CORBA_ExceptionDef ** ACE_CAST_CONST, this->buffer_);
-    return TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var> (tmp + index, this->release_);
+    ACE_ASSERT (i < this->maximum_);
+    IR::OperationDescription* tmp = ACE_reinterpret_cast(IR::OperationDescription*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const IR::OperationDescription &
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    IR::OperationDescription * const tmp = ACE_reinterpret_cast (IR::OperationDescription* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
   }
   
-  ACE_INLINE CORBA_ExceptionDef* *
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (CORBA::Boolean orphan)
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE IR::OperationDescription *
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_ExceptionDef **result = 0;
+    IR::OperationDescription *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::allocbuf (this->maximum_);
+        result = _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::allocbuf (this->length_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_ExceptionDef**, this->buffer_);
+        result = ACE_reinterpret_cast (IR::OperationDescription*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -8977,7 +13914,7 @@ CORBA_ContextIdSeq_out::operator[] (CORBA::ULong index)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_ExceptionDef**,this->buffer_);
+        result = ACE_reinterpret_cast(IR::OperationDescription*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -8987,156 +13924,176 @@ CORBA_ContextIdSeq_out::operator[] (CORBA::ULong index)
     return result;
   }
   
-  ACE_INLINE const CORBA_ExceptionDef* *
-  _TAO_Unbounded_Object_Sequence_CORBA_ExceptionDefSeq::get_buffer (void) const
+  ACE_INLINE const IR::OperationDescription *
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_ExceptionDef ** ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::OperationDescription * ACE_CAST_CONST, this->buffer_);
   }
   
+  ACE_INLINE void
+  IR::_TAO_Unbounded_Sequence_IR_OpDescriptionSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  IR::OperationDescription *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      IR::OperationDescription *tmp = ACE_reinterpret_cast(IR::OperationDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_OpDescriptionSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
   
 #endif /* end #if !defined */
 
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_EXCEPTIONDEFSEQ_CI_)
-#define _CORBA_EXCEPTIONDEFSEQ_CI_
+#if !defined (_IR_OPDESCRIPTIONSEQ_CI_)
+#define _IR_OPDESCRIPTIONSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ExceptionDefSeq_var
+// Inline operations for class IR::OpDescriptionSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ExceptionDefSeq_var::CORBA_ExceptionDefSeq_var (void) // default constructor
+IR::OpDescriptionSeq_var::OpDescriptionSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ExceptionDefSeq_var::CORBA_ExceptionDefSeq_var (CORBA_ExceptionDefSeq *p)
+IR::OpDescriptionSeq_var::OpDescriptionSeq_var (OpDescriptionSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ExceptionDefSeq_var::CORBA_ExceptionDefSeq_var (const CORBA_ExceptionDefSeq_var &p) // copy constructor
+IR::OpDescriptionSeq_var::OpDescriptionSeq_var (const ::IR::OpDescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ExceptionDefSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::OpDescriptionSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ExceptionDefSeq_var::~CORBA_ExceptionDefSeq_var (void) // destructor
+IR::OpDescriptionSeq_var::~OpDescriptionSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDefSeq_var &
-CORBA_ExceptionDefSeq_var::operator= (CORBA_ExceptionDefSeq *p)
+ACE_INLINE IR::OpDescriptionSeq_var &
+IR::OpDescriptionSeq_var::operator= (OpDescriptionSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ExceptionDefSeq_var &
-CORBA_ExceptionDefSeq_var::operator= (const CORBA_ExceptionDefSeq_var &p) // deep copy
+ACE_INLINE IR::OpDescriptionSeq_var &
+IR::OpDescriptionSeq_var::operator= (const ::IR::OpDescriptionSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ExceptionDefSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::OpDescriptionSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ExceptionDefSeq *
-CORBA_ExceptionDefSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::OpDescriptionSeq *
+IR::OpDescriptionSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDefSeq *
-CORBA_ExceptionDefSeq_var::operator-> (void)
+ACE_INLINE ::IR::OpDescriptionSeq *
+IR::OpDescriptionSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDefSeq_var::operator const CORBA_ExceptionDefSeq &() const // cast
+IR::OpDescriptionSeq_var::operator const ::IR::OpDescriptionSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDefSeq_var::operator CORBA_ExceptionDefSeq &() // cast 
+IR::OpDescriptionSeq_var::operator ::IR::OpDescriptionSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDefSeq_var::operator CORBA_ExceptionDefSeq &() const// cast 
+IR::OpDescriptionSeq_var::operator ::IR::OpDescriptionSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var> 
-CORBA_ExceptionDefSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::OpDescriptionSeq_var::operator ::IR::OpDescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::OperationDescription &
+IR::OpDescriptionSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_ExceptionDefSeq &
-CORBA_ExceptionDefSeq_var::in (void) const
+ACE_INLINE const ::IR::OpDescriptionSeq &
+IR::OpDescriptionSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDefSeq &
-CORBA_ExceptionDefSeq_var::inout (void)
+ACE_INLINE ::IR::OpDescriptionSeq &
+IR::OpDescriptionSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ExceptionDefSeq *&
-CORBA_ExceptionDefSeq_var::out (void)
+ACE_INLINE ::IR::OpDescriptionSeq *&
+IR::OpDescriptionSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDefSeq *
-CORBA_ExceptionDefSeq_var::_retn (void)
+ACE_INLINE ::IR::OpDescriptionSeq *
+IR::OpDescriptionSeq_var::_retn (void)
 {
-  CORBA_ExceptionDefSeq *tmp = this->ptr_;
+  ::IR::OpDescriptionSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ExceptionDefSeq *
-CORBA_ExceptionDefSeq_var::ptr (void) const
+ACE_INLINE ::IR::OpDescriptionSeq *
+IR::OpDescriptionSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ExceptionDefSeq_out
+// Inline operations for class IR::OpDescriptionSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ExceptionDefSeq_out::CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq *&p)
+IR::OpDescriptionSeq_out::OpDescriptionSeq_out (OpDescriptionSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ExceptionDefSeq_out::CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq_var &p) // constructor from _var
+IR::OpDescriptionSeq_out::OpDescriptionSeq_out (OpDescriptionSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -9144,44 +14101,44 @@ CORBA_ExceptionDefSeq_out::CORBA_ExceptionDefSeq_out (CORBA_ExceptionDefSeq_var
 }
 
 ACE_INLINE
-CORBA_ExceptionDefSeq_out::CORBA_ExceptionDefSeq_out (const CORBA_ExceptionDefSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ExceptionDefSeq_out&,p).ptr_)
+IR::OpDescriptionSeq_out::OpDescriptionSeq_out (const ::IR::OpDescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (OpDescriptionSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ExceptionDefSeq_out &
-CORBA_ExceptionDefSeq_out::operator= (const CORBA_ExceptionDefSeq_out &p)
+ACE_INLINE ::IR::OpDescriptionSeq_out &
+IR::OpDescriptionSeq_out::operator= (const ::IR::OpDescriptionSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ExceptionDefSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (OpDescriptionSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ExceptionDefSeq_out &
-CORBA_ExceptionDefSeq_out::operator= (CORBA_ExceptionDefSeq *p)
+ACE_INLINE ::IR::OpDescriptionSeq_out &
+IR::OpDescriptionSeq_out::operator= (OpDescriptionSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ExceptionDefSeq_out::operator CORBA_ExceptionDefSeq *&() // cast
+IR::OpDescriptionSeq_out::operator ::IR::OpDescriptionSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDefSeq *&
-CORBA_ExceptionDefSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::OpDescriptionSeq *&
+IR::OpDescriptionSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDefSeq *
-CORBA_ExceptionDefSeq_out::operator-> (void)
+ACE_INLINE ::IR::OpDescriptionSeq *
+IR::OpDescriptionSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE TAO_Object_Manager<CORBA_ExceptionDef,CORBA_ExceptionDef_var> 
-CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE IR::OperationDescription &
+IR::OpDescriptionSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -9192,63 +14149,68 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CI_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_EXCDESCRIPTIONSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_ATTRDESCRIPTIONSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_ATTRDESCRIPTIONSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE CORBA_ExceptionDescription *
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE IR::AttributeDescription *
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    CORBA_ExceptionDescription *retval = 0;
-    ACE_NEW_RETURN (retval,
-                    CORBA_ExceptionDescription[size],
-		    0);
+    IR::AttributeDescription *retval = 0;
+    ACE_NEW_RETURN (retval, IR::AttributeDescription[size], 0);
     return retval;
   }
   
-  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (CORBA_ExceptionDescription *buffer)
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (IR::AttributeDescription *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (void) // Default constructor.
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_ExceptionDescription *data,
+    IR::AttributeDescription *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_ExceptionDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (this->maximum_);
-    CORBA_ExceptionDescription * const tmp2 = ACE_reinterpret_cast (CORBA_ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    this->buffer_ = tmp1;
+    if (rhs.buffer_ != 0)
+    {
+      IR::AttributeDescription *tmp1 = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (this->maximum_);
+      IR::AttributeDescription * const tmp2 = ACE_reinterpret_cast (IR::AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq &rhs)
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -9259,18 +14221,18 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        CORBA_ExceptionDescription *tmp = ACE_reinterpret_cast (CORBA_ExceptionDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (rhs.maximum_);
+        IR::AttributeDescription *tmp = ACE_reinterpret_cast (IR::AttributeDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_ExceptionDescription *tmp1 = ACE_reinterpret_cast (CORBA_ExceptionDescription *, this->buffer_);
-    CORBA_ExceptionDescription * const tmp2 = ACE_reinterpret_cast (CORBA_ExceptionDescription * ACE_CAST_CONST, rhs.buffer_);
+    IR::AttributeDescription *tmp1 = ACE_reinterpret_cast (IR::AttributeDescription *, this->buffer_);
+    IR::AttributeDescription * const tmp2 = ACE_reinterpret_cast (IR::AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -9279,41 +14241,41 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
   }
   
   // = Accessors.
-  ACE_INLINE CORBA_ExceptionDescription &
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE IR::AttributeDescription &
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_ExceptionDescription* tmp = ACE_reinterpret_cast(CORBA_ExceptionDescription*,this->buffer_);
+    IR::AttributeDescription* tmp = ACE_reinterpret_cast(IR::AttributeDescription*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const CORBA_ExceptionDescription &
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const IR::AttributeDescription &
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_ExceptionDescription * const tmp = ACE_reinterpret_cast (CORBA_ExceptionDescription* ACE_CAST_CONST, this->buffer_);
+    IR::AttributeDescription * const tmp = ACE_reinterpret_cast (IR::AttributeDescription* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE CORBA_ExceptionDescription *
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::AttributeDescription *
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_ExceptionDescription *result = 0;
+    IR::AttributeDescription *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::allocbuf (this->length_);
+        result = _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::allocbuf (this->length_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_ExceptionDescription*, this->buffer_);
+        result = ACE_reinterpret_cast (IR::AttributeDescription*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -9322,7 +14284,7 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_ExceptionDescription*,this->buffer_);
+        result = ACE_reinterpret_cast(IR::AttributeDescription*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -9332,24 +14294,24 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
     return result;
   }
   
-  ACE_INLINE const CORBA_ExceptionDescription *
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::get_buffer (void) const
+  ACE_INLINE const IR::AttributeDescription *
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_ExceptionDescription * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::AttributeDescription * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::replace (CORBA::ULong max,
+  IR::_TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  CORBA_ExceptionDescription *data,
+  IR::AttributeDescription *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      CORBA_ExceptionDescription *tmp = ACE_reinterpret_cast(CORBA_ExceptionDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_CORBA_ExcDescriptionSeq::freebuf (tmp);
+      IR::AttributeDescription *tmp = ACE_reinterpret_cast(IR::AttributeDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_AttrDescriptionSeq::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -9360,144 +14322,148 @@ CORBA_ExceptionDefSeq_out::operator[] (CORBA::ULong index)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_EXCDESCRIPTIONSEQ_CI_)
-#define _CORBA_EXCDESCRIPTIONSEQ_CI_
+#if !defined (_IR_ATTRDESCRIPTIONSEQ_CI_)
+#define _IR_ATTRDESCRIPTIONSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ExcDescriptionSeq_var
+// Inline operations for class IR::AttrDescriptionSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ExcDescriptionSeq_var::CORBA_ExcDescriptionSeq_var (void) // default constructor
+IR::AttrDescriptionSeq_var::AttrDescriptionSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ExcDescriptionSeq_var::CORBA_ExcDescriptionSeq_var (CORBA_ExcDescriptionSeq *p)
+IR::AttrDescriptionSeq_var::AttrDescriptionSeq_var (AttrDescriptionSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ExcDescriptionSeq_var::CORBA_ExcDescriptionSeq_var (const CORBA_ExcDescriptionSeq_var &p) // copy constructor
+IR::AttrDescriptionSeq_var::AttrDescriptionSeq_var (const ::IR::AttrDescriptionSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ExcDescriptionSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::AttrDescriptionSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ExcDescriptionSeq_var::~CORBA_ExcDescriptionSeq_var (void) // destructor
+IR::AttrDescriptionSeq_var::~AttrDescriptionSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ExcDescriptionSeq_var &
-CORBA_ExcDescriptionSeq_var::operator= (CORBA_ExcDescriptionSeq *p)
+ACE_INLINE IR::AttrDescriptionSeq_var &
+IR::AttrDescriptionSeq_var::operator= (AttrDescriptionSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ExcDescriptionSeq_var &
-CORBA_ExcDescriptionSeq_var::operator= (const CORBA_ExcDescriptionSeq_var &p) // deep copy
+ACE_INLINE IR::AttrDescriptionSeq_var &
+IR::AttrDescriptionSeq_var::operator= (const ::IR::AttrDescriptionSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ExcDescriptionSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::AttrDescriptionSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ExcDescriptionSeq *
-CORBA_ExcDescriptionSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::AttrDescriptionSeq *
+IR::AttrDescriptionSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExcDescriptionSeq *
-CORBA_ExcDescriptionSeq_var::operator-> (void)
+ACE_INLINE ::IR::AttrDescriptionSeq *
+IR::AttrDescriptionSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExcDescriptionSeq_var::operator const CORBA_ExcDescriptionSeq &() const // cast
+IR::AttrDescriptionSeq_var::operator const ::IR::AttrDescriptionSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExcDescriptionSeq_var::operator CORBA_ExcDescriptionSeq &() // cast 
+IR::AttrDescriptionSeq_var::operator ::IR::AttrDescriptionSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ExcDescriptionSeq_var::operator CORBA_ExcDescriptionSeq &() const// cast 
+IR::AttrDescriptionSeq_var::operator ::IR::AttrDescriptionSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDescription &
-CORBA_ExcDescriptionSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::AttrDescriptionSeq_var::operator ::IR::AttrDescriptionSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::AttributeDescription &
+IR::AttrDescriptionSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_ExcDescriptionSeq &
-CORBA_ExcDescriptionSeq_var::in (void) const
+ACE_INLINE const ::IR::AttrDescriptionSeq &
+IR::AttrDescriptionSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ExcDescriptionSeq &
-CORBA_ExcDescriptionSeq_var::inout (void)
+ACE_INLINE ::IR::AttrDescriptionSeq &
+IR::AttrDescriptionSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ExcDescriptionSeq *&
-CORBA_ExcDescriptionSeq_var::out (void)
+ACE_INLINE ::IR::AttrDescriptionSeq *&
+IR::AttrDescriptionSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExcDescriptionSeq *
-CORBA_ExcDescriptionSeq_var::_retn (void)
+ACE_INLINE ::IR::AttrDescriptionSeq *
+IR::AttrDescriptionSeq_var::_retn (void)
 {
-  CORBA_ExcDescriptionSeq *tmp = this->ptr_;
+  ::IR::AttrDescriptionSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ExcDescriptionSeq *
-CORBA_ExcDescriptionSeq_var::ptr (void) const
+ACE_INLINE ::IR::AttrDescriptionSeq *
+IR::AttrDescriptionSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ExcDescriptionSeq_out
+// Inline operations for class IR::AttrDescriptionSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ExcDescriptionSeq_out::CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSeq *&p)
+IR::AttrDescriptionSeq_out::AttrDescriptionSeq_out (AttrDescriptionSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ExcDescriptionSeq_out::CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSeq_var &p) // constructor from _var
+IR::AttrDescriptionSeq_out::AttrDescriptionSeq_out (AttrDescriptionSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -9505,44 +14471,44 @@ CORBA_ExcDescriptionSeq_out::CORBA_ExcDescriptionSeq_out (CORBA_ExcDescriptionSe
 }
 
 ACE_INLINE
-CORBA_ExcDescriptionSeq_out::CORBA_ExcDescriptionSeq_out (const CORBA_ExcDescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ExcDescriptionSeq_out&,p).ptr_)
+IR::AttrDescriptionSeq_out::AttrDescriptionSeq_out (const ::IR::AttrDescriptionSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (AttrDescriptionSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ExcDescriptionSeq_out &
-CORBA_ExcDescriptionSeq_out::operator= (const CORBA_ExcDescriptionSeq_out &p)
+ACE_INLINE ::IR::AttrDescriptionSeq_out &
+IR::AttrDescriptionSeq_out::operator= (const ::IR::AttrDescriptionSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ExcDescriptionSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (AttrDescriptionSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ExcDescriptionSeq_out &
-CORBA_ExcDescriptionSeq_out::operator= (CORBA_ExcDescriptionSeq *p)
+ACE_INLINE ::IR::AttrDescriptionSeq_out &
+IR::AttrDescriptionSeq_out::operator= (AttrDescriptionSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ExcDescriptionSeq_out::operator CORBA_ExcDescriptionSeq *&() // cast
+IR::AttrDescriptionSeq_out::operator ::IR::AttrDescriptionSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExcDescriptionSeq *&
-CORBA_ExcDescriptionSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::AttrDescriptionSeq *&
+IR::AttrDescriptionSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExcDescriptionSeq *
-CORBA_ExcDescriptionSeq_out::operator-> (void)
+ACE_INLINE ::IR::AttrDescriptionSeq *
+IR::AttrDescriptionSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ExceptionDescription &
-CORBA_ExcDescriptionSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE IR::AttributeDescription &
+IR::AttrDescriptionSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -9551,116 +14517,116 @@ CORBA_ExcDescriptionSeq_out::operator[] (CORBA::ULong index)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_OperationDef::CORBA_OperationDef (void) // default constructor
+IR::InterfaceDef::InterfaceDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_OperationDef::CORBA_OperationDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::InterfaceDef::InterfaceDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_OperationDef::~CORBA_OperationDef (void) // destructor
+IR::InterfaceDef::~InterfaceDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_OPERATIONDEF___VAR_CI_)
-#define _CORBA_OPERATIONDEF___VAR_CI_
+#if !defined (_IR_INTERFACEDEF___VAR_CI_)
+#define _IR_INTERFACEDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_OperationDef_var
+// Inline operations for class IR::InterfaceDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_OperationDef_var::CORBA_OperationDef_var (void) // default constructor
-  : ptr_ (CORBA_OperationDef::_nil ())
+IR::InterfaceDef_var::InterfaceDef_var (void) // default constructor
+  : ptr_ (InterfaceDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_OperationDef_var::CORBA_OperationDef_var (CORBA_OperationDef_ptr p)
+IR::InterfaceDef_var::InterfaceDef_var (InterfaceDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_OperationDef_ptr 
-CORBA_OperationDef_var::ptr (void) const
+ACE_INLINE ::IR::InterfaceDef_ptr
+IR::InterfaceDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_OperationDef_var::CORBA_OperationDef_var (const CORBA_OperationDef_var &p) // copy constructor
-  : ptr_ (CORBA_OperationDef::_duplicate (p.ptr ()))
+IR::InterfaceDef_var::InterfaceDef_var (const ::IR::InterfaceDef_var &p) // copy constructor
+  : ptr_ (InterfaceDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_OperationDef_var::~CORBA_OperationDef_var (void) // destructor
+IR::InterfaceDef_var::~InterfaceDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_OperationDef_var &
-CORBA_OperationDef_var::operator= (CORBA_OperationDef_ptr p)
+ACE_INLINE IR::InterfaceDef_var &
+IR::InterfaceDef_var::operator= (InterfaceDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_OperationDef_var &
-CORBA_OperationDef_var::operator= (const CORBA_OperationDef_var &p)
+ACE_INLINE IR::InterfaceDef_var &
+IR::InterfaceDef_var::operator= (const ::IR::InterfaceDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_OperationDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::InterfaceDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_OperationDef_var::operator const CORBA_OperationDef_ptr &() const // cast
+IR::InterfaceDef_var::operator const ::IR::InterfaceDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_OperationDef_var::operator CORBA_OperationDef_ptr &() // cast 
+IR::InterfaceDef_var::operator ::IR::InterfaceDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDef_ptr 
-CORBA_OperationDef_var::operator-> (void) const
+ACE_INLINE ::IR::InterfaceDef_ptr
+IR::InterfaceDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDef_ptr
-CORBA_OperationDef_var::in (void) const
+ACE_INLINE ::IR::InterfaceDef_ptr
+IR::InterfaceDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDef_ptr &
-CORBA_OperationDef_var::inout (void)
+ACE_INLINE ::IR::InterfaceDef_ptr &
+IR::InterfaceDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDef_ptr &
-CORBA_OperationDef_var::out (void)
+ACE_INLINE ::IR::InterfaceDef_ptr &
+IR::InterfaceDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_OperationDef::_nil ();
+  this->ptr_ = ::IR::InterfaceDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDef_ptr 
-CORBA_OperationDef_var::_retn (void)
+ACE_INLINE ::IR::InterfaceDef_ptr
+IR::InterfaceDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_OperationDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_OperationDef::_nil ();
+  ::IR::InterfaceDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::InterfaceDef::_nil ();
   return val;
 }
 
@@ -9668,68 +14634,68 @@ CORBA_OperationDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_OPERATIONDEF___OUT_CI_)
-#define _CORBA_OPERATIONDEF___OUT_CI_
+#if !defined (_IR_INTERFACEDEF___OUT_CI_)
+#define _IR_INTERFACEDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_OperationDef_out
+// Inline operations for class IR::InterfaceDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_OperationDef_out::CORBA_OperationDef_out (CORBA_OperationDef_ptr &p)
+IR::InterfaceDef_out::InterfaceDef_out (InterfaceDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_OperationDef::_nil ();
+  this->ptr_ = ::IR::InterfaceDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_OperationDef_out::CORBA_OperationDef_out (CORBA_OperationDef_var &p) // constructor from _var
+IR::InterfaceDef_out::InterfaceDef_out (InterfaceDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_OperationDef::_nil ();
+  this->ptr_ = ::IR::InterfaceDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_OperationDef_out::CORBA_OperationDef_out (const CORBA_OperationDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_OperationDef_out&,p).ptr_)
+IR::InterfaceDef_out::InterfaceDef_out (const ::IR::InterfaceDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (InterfaceDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_OperationDef_out &
-CORBA_OperationDef_out::operator= (const CORBA_OperationDef_out &p)
+ACE_INLINE ::IR::InterfaceDef_out &
+IR::InterfaceDef_out::operator= (const ::IR::InterfaceDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_OperationDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (InterfaceDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_OperationDef_out &
-CORBA_OperationDef_out::operator= (const CORBA_OperationDef_var &p)
+ACE_INLINE IR::InterfaceDef_out &
+IR::InterfaceDef_out::operator= (const ::IR::InterfaceDef_var &p)
 {
-  this->ptr_ = CORBA_OperationDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::InterfaceDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_OperationDef_out &
-CORBA_OperationDef_out::operator= (CORBA_OperationDef_ptr p)
+ACE_INLINE IR::InterfaceDef_out &
+IR::InterfaceDef_out::operator= (InterfaceDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_OperationDef_out::operator CORBA_OperationDef_ptr &() // cast
+IR::InterfaceDef_out::operator ::IR::InterfaceDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDef_ptr &
-CORBA_OperationDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::InterfaceDef_ptr &
+IR::InterfaceDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDef_ptr 
-CORBA_OperationDef_out::operator-> (void)
+ACE_INLINE ::IR::InterfaceDef_ptr
+IR::InterfaceDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -9738,134 +14704,138 @@ CORBA_OperationDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA_OperationDescription_var
+// Inline operations for class IR::InterfaceDescription_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_OperationDescription_var::CORBA_OperationDescription_var (void) // default constructor
+IR::InterfaceDescription_var::InterfaceDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_OperationDescription_var::CORBA_OperationDescription_var (CORBA_OperationDescription *p)
+IR::InterfaceDescription_var::InterfaceDescription_var (InterfaceDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_OperationDescription_var::CORBA_OperationDescription_var (const CORBA_OperationDescription_var &p) // copy constructor
+IR::InterfaceDescription_var::InterfaceDescription_var (const ::IR::InterfaceDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_OperationDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::InterfaceDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_OperationDescription_var::~CORBA_OperationDescription_var (void) // destructor
+IR::InterfaceDescription_var::~InterfaceDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDescription_var &
-CORBA_OperationDescription_var::operator= (CORBA_OperationDescription *p)
+ACE_INLINE IR::InterfaceDescription_var &
+IR::InterfaceDescription_var::operator= (InterfaceDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_OperationDescription_var &
-CORBA_OperationDescription_var::operator= (const CORBA_OperationDescription_var &p)
+ACE_INLINE ::IR::InterfaceDescription_var &
+IR::InterfaceDescription_var::operator= (const ::IR::InterfaceDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_OperationDescription (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::InterfaceDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_OperationDescription *
-CORBA_OperationDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::InterfaceDescription *
+IR::InterfaceDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDescription *
-CORBA_OperationDescription_var::operator-> (void)
+ACE_INLINE ::IR::InterfaceDescription *
+IR::InterfaceDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_OperationDescription_var::operator const CORBA_OperationDescription &() const // cast
+ACE_INLINE
+IR::InterfaceDescription_var::operator const ::IR::InterfaceDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_OperationDescription_var::operator CORBA_OperationDescription &() // cast 
+ACE_INLINE
+IR::InterfaceDescription_var::operator ::IR::InterfaceDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_OperationDescription_var::operator CORBA_OperationDescription &() const// cast 
+ACE_INLINE
+IR::InterfaceDescription_var::operator ::IR::InterfaceDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_OperationDescription &
-CORBA_OperationDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::InterfaceDescription_var::operator ::IR::InterfaceDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::InterfaceDescription &
+IR::InterfaceDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDescription &
-CORBA_OperationDescription_var::inout (void)
+ACE_INLINE ::IR::InterfaceDescription &
+IR::InterfaceDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_OperationDescription *&
-CORBA_OperationDescription_var::out (void)
+ACE_INLINE ::IR::InterfaceDescription *&
+IR::InterfaceDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDescription *
-CORBA_OperationDescription_var::_retn (void)
+ACE_INLINE ::IR::InterfaceDescription *
+IR::InterfaceDescription_var::_retn (void)
 {
-  CORBA_OperationDescription *tmp = this->ptr_;
+  ::IR::InterfaceDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_OperationDescription *
-CORBA_OperationDescription_var::ptr (void) const
+ACE_INLINE ::IR::InterfaceDescription *
+IR::InterfaceDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_OperationDescription_out
+// Inline operations for class IR::InterfaceDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_OperationDescription_out::CORBA_OperationDescription_out (CORBA_OperationDescription *&p)
+IR::InterfaceDescription_out::InterfaceDescription_out (::IR::InterfaceDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_OperationDescription_out::CORBA_OperationDescription_out (CORBA_OperationDescription_var &p) // constructor from _var
+IR::InterfaceDescription_out::InterfaceDescription_out (InterfaceDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -9873,181 +14843,175 @@ CORBA_OperationDescription_out::CORBA_OperationDescription_out (CORBA_OperationD
 }
 
 ACE_INLINE
-CORBA_OperationDescription_out::CORBA_OperationDescription_out (const CORBA_OperationDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_OperationDescription_out&,p).ptr_)
+IR::InterfaceDescription_out::InterfaceDescription_out (const ::IR::InterfaceDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (InterfaceDescription_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_OperationDescription_out &
-CORBA_OperationDescription_out::operator= (const CORBA_OperationDescription_out &p)
+ACE_INLINE IR::InterfaceDescription_out &
+IR::InterfaceDescription_out::operator= (const ::IR::InterfaceDescription_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_OperationDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (InterfaceDescription_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_OperationDescription_out &
-CORBA_OperationDescription_out::operator= (CORBA_OperationDescription *p)
+ACE_INLINE IR::InterfaceDescription_out &
+IR::InterfaceDescription_out::operator= (InterfaceDescription *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_OperationDescription_out::operator CORBA_OperationDescription *&() // cast
+IR::InterfaceDescription_out::operator ::IR::InterfaceDescription *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDescription *&
-CORBA_OperationDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::InterfaceDescription *&
+IR::InterfaceDescription_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDescription *
-CORBA_OperationDescription_out::operator-> (void)
+ACE_INLINE ::IR::InterfaceDescription *
+IR::InterfaceDescription_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-
-#if !defined (_CORBA_REPOSITORYIDSEQ_CI_)
-#define _CORBA_REPOSITORYIDSEQ_CI_
-
 // *************************************************************
-// Inline operations for class CORBA_RepositoryIdSeq_var
+// Inline operations for class IR::ValueMember_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_RepositoryIdSeq_var::CORBA_RepositoryIdSeq_var (void) // default constructor
+IR::ValueMember_var::ValueMember_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_RepositoryIdSeq_var::CORBA_RepositoryIdSeq_var (CORBA_RepositoryIdSeq *p)
+IR::ValueMember_var::ValueMember_var (ValueMember *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_RepositoryIdSeq_var::CORBA_RepositoryIdSeq_var (const CORBA_RepositoryIdSeq_var &p) // copy constructor
+IR::ValueMember_var::ValueMember_var (const ::IR::ValueMember_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_RepositoryIdSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ValueMember (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_RepositoryIdSeq_var::~CORBA_RepositoryIdSeq_var (void) // destructor
+IR::ValueMember_var::~ValueMember_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_RepositoryIdSeq_var &
-CORBA_RepositoryIdSeq_var::operator= (CORBA_RepositoryIdSeq *p)
+ACE_INLINE IR::ValueMember_var &
+IR::ValueMember_var::operator= (ValueMember *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_RepositoryIdSeq_var &
-CORBA_RepositoryIdSeq_var::operator= (const CORBA_RepositoryIdSeq_var &p) // deep copy
+ACE_INLINE ::IR::ValueMember_var &
+IR::ValueMember_var::operator= (const ::IR::ValueMember_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_RepositoryIdSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ValueMember (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_RepositoryIdSeq *
-CORBA_RepositoryIdSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::ValueMember *
+IR::ValueMember_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_RepositoryIdSeq *
-CORBA_RepositoryIdSeq_var::operator-> (void)
+ACE_INLINE ::IR::ValueMember *
+IR::ValueMember_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_RepositoryIdSeq_var::operator const CORBA_RepositoryIdSeq &() const // cast
+ACE_INLINE
+IR::ValueMember_var::operator const ::IR::ValueMember &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_RepositoryIdSeq_var::operator CORBA_RepositoryIdSeq &() // cast 
+ACE_INLINE
+IR::ValueMember_var::operator ::IR::ValueMember &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_RepositoryIdSeq_var::operator CORBA_RepositoryIdSeq &() const// cast 
+ACE_INLINE
+IR::ValueMember_var::operator ::IR::ValueMember &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE TAO_SeqElem_String_Manager 
-CORBA_RepositoryIdSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::ValueMember_var::operator ::IR::ValueMember *&() // cast 
 {
-  return this->ptr_->operator[] (index);
+  return this->ptr_;
 }
 
-ACE_INLINE const CORBA_RepositoryIdSeq &
-CORBA_RepositoryIdSeq_var::in (void) const
+ACE_INLINE const ::IR::ValueMember &
+IR::ValueMember_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_RepositoryIdSeq &
-CORBA_RepositoryIdSeq_var::inout (void)
+ACE_INLINE ::IR::ValueMember &
+IR::ValueMember_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_RepositoryIdSeq *&
-CORBA_RepositoryIdSeq_var::out (void)
+ACE_INLINE ::IR::ValueMember *&
+IR::ValueMember_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_RepositoryIdSeq *
-CORBA_RepositoryIdSeq_var::_retn (void)
+ACE_INLINE ::IR::ValueMember *
+IR::ValueMember_var::_retn (void)
 {
-  CORBA_RepositoryIdSeq *tmp = this->ptr_;
+  ::IR::ValueMember *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_RepositoryIdSeq *
-CORBA_RepositoryIdSeq_var::ptr (void) const
+ACE_INLINE ::IR::ValueMember *
+IR::ValueMember_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_RepositoryIdSeq_out
+// Inline operations for class IR::ValueMember_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_RepositoryIdSeq_out::CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq *&p)
+IR::ValueMember_out::ValueMember_out (::IR::ValueMember *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_RepositoryIdSeq_out::CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq_var &p) // constructor from _var
+IR::ValueMember_out::ValueMember_out (ValueMember_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -10055,111 +15019,107 @@ CORBA_RepositoryIdSeq_out::CORBA_RepositoryIdSeq_out (CORBA_RepositoryIdSeq_var
 }
 
 ACE_INLINE
-CORBA_RepositoryIdSeq_out::CORBA_RepositoryIdSeq_out (const CORBA_RepositoryIdSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_RepositoryIdSeq_out&,p).ptr_)
+IR::ValueMember_out::ValueMember_out (const ::IR::ValueMember_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ValueMember_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_RepositoryIdSeq_out &
-CORBA_RepositoryIdSeq_out::operator= (const CORBA_RepositoryIdSeq_out &p)
+ACE_INLINE IR::ValueMember_out &
+IR::ValueMember_out::operator= (const ::IR::ValueMember_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_RepositoryIdSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ValueMember_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_RepositoryIdSeq_out &
-CORBA_RepositoryIdSeq_out::operator= (CORBA_RepositoryIdSeq *p)
+ACE_INLINE IR::ValueMember_out &
+IR::ValueMember_out::operator= (ValueMember *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_RepositoryIdSeq_out::operator CORBA_RepositoryIdSeq *&() // cast
+IR::ValueMember_out::operator ::IR::ValueMember *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_RepositoryIdSeq *&
-CORBA_RepositoryIdSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::ValueMember *&
+IR::ValueMember_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_RepositoryIdSeq *
-CORBA_RepositoryIdSeq_out::operator-> (void)
+ACE_INLINE ::IR::ValueMember *
+IR::ValueMember_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE TAO_SeqElem_String_Manager 
-CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
-{
-  return this->ptr_->operator[] (index);
-}
-
-
-#endif /* end #if !defined */
-
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CI_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_OPDESCRIPTIONSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_VALUEMEMBERSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_VALUEMEMBERSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE CORBA_OperationDescription *
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE IR::ValueMember *
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    CORBA_OperationDescription *retval = 0;
-    ACE_NEW_RETURN (retval,
-                    CORBA_OperationDescription[size],
-		    0);
+    IR::ValueMember *retval = 0;
+    ACE_NEW_RETURN (retval, IR::ValueMember[size], 0);
     return retval;
   }
   
-  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (CORBA_OperationDescription *buffer)
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (IR::ValueMember *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (void) // Default constructor.
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::_TAO_Unbounded_Sequence_IR_ValueMemberSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::_TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::_TAO_Unbounded_Sequence_IR_ValueMemberSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_OperationDescription *data,
+    IR::ValueMember *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::_TAO_Unbounded_Sequence_IR_ValueMemberSeq (const _TAO_Unbounded_Sequence_IR_ValueMemberSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_OperationDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (this->maximum_);
-    CORBA_OperationDescription * const tmp2 = ACE_reinterpret_cast (CORBA_OperationDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    this->buffer_ = tmp1;
+    if (rhs.buffer_ != 0)
+    {
+      IR::ValueMember *tmp1 = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (this->maximum_);
+      IR::ValueMember * const tmp2 = ACE_reinterpret_cast (IR::ValueMember * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq &rhs)
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq &
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::operator= (const _TAO_Unbounded_Sequence_IR_ValueMemberSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -10170,18 +15130,18 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        CORBA_OperationDescription *tmp = ACE_reinterpret_cast (CORBA_OperationDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (rhs.maximum_);
+        IR::ValueMember *tmp = ACE_reinterpret_cast (IR::ValueMember *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_OperationDescription *tmp1 = ACE_reinterpret_cast (CORBA_OperationDescription *, this->buffer_);
-    CORBA_OperationDescription * const tmp2 = ACE_reinterpret_cast (CORBA_OperationDescription * ACE_CAST_CONST, rhs.buffer_);
+    IR::ValueMember *tmp1 = ACE_reinterpret_cast (IR::ValueMember *, this->buffer_);
+    IR::ValueMember * const tmp2 = ACE_reinterpret_cast (IR::ValueMember * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -10190,41 +15150,41 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
   }
   
   // = Accessors.
-  ACE_INLINE CORBA_OperationDescription &
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE IR::ValueMember &
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_OperationDescription* tmp = ACE_reinterpret_cast(CORBA_OperationDescription*,this->buffer_);
+    IR::ValueMember* tmp = ACE_reinterpret_cast(IR::ValueMember*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const CORBA_OperationDescription &
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const IR::ValueMember &
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_OperationDescription * const tmp = ACE_reinterpret_cast (CORBA_OperationDescription* ACE_CAST_CONST, this->buffer_);
+    IR::ValueMember * const tmp = ACE_reinterpret_cast (IR::ValueMember* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE CORBA_OperationDescription *
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::ValueMember *
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_OperationDescription *result = 0;
+    IR::ValueMember *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::allocbuf (this->length_);
+        result = _TAO_Unbounded_Sequence_IR_ValueMemberSeq::allocbuf (this->length_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_OperationDescription*, this->buffer_);
+        result = ACE_reinterpret_cast (IR::ValueMember*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -10233,7 +15193,7 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_OperationDescription*,this->buffer_);
+        result = ACE_reinterpret_cast(IR::ValueMember*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -10243,24 +15203,24 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
     return result;
   }
   
-  ACE_INLINE const CORBA_OperationDescription *
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::get_buffer (void) const
+  ACE_INLINE const IR::ValueMember *
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_OperationDescription * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::ValueMember * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::replace (CORBA::ULong max,
+  IR::_TAO_Unbounded_Sequence_IR_ValueMemberSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  CORBA_OperationDescription *data,
+  IR::ValueMember *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      CORBA_OperationDescription *tmp = ACE_reinterpret_cast(CORBA_OperationDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_CORBA_OpDescriptionSeq::freebuf (tmp);
+      IR::ValueMember *tmp = ACE_reinterpret_cast(IR::ValueMember*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_ValueMemberSeq::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -10271,144 +15231,148 @@ CORBA_RepositoryIdSeq_out::operator[] (CORBA::ULong index)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_OPDESCRIPTIONSEQ_CI_)
-#define _CORBA_OPDESCRIPTIONSEQ_CI_
+#if !defined (_IR_VALUEMEMBERSEQ_CI_)
+#define _IR_VALUEMEMBERSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_OpDescriptionSeq_var
+// Inline operations for class IR::ValueMemberSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_OpDescriptionSeq_var::CORBA_OpDescriptionSeq_var (void) // default constructor
+IR::ValueMemberSeq_var::ValueMemberSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_OpDescriptionSeq_var::CORBA_OpDescriptionSeq_var (CORBA_OpDescriptionSeq *p)
+IR::ValueMemberSeq_var::ValueMemberSeq_var (ValueMemberSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_OpDescriptionSeq_var::CORBA_OpDescriptionSeq_var (const CORBA_OpDescriptionSeq_var &p) // copy constructor
+IR::ValueMemberSeq_var::ValueMemberSeq_var (const ::IR::ValueMemberSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_OpDescriptionSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ValueMemberSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_OpDescriptionSeq_var::~CORBA_OpDescriptionSeq_var (void) // destructor
+IR::ValueMemberSeq_var::~ValueMemberSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_OpDescriptionSeq_var &
-CORBA_OpDescriptionSeq_var::operator= (CORBA_OpDescriptionSeq *p)
+ACE_INLINE IR::ValueMemberSeq_var &
+IR::ValueMemberSeq_var::operator= (ValueMemberSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_OpDescriptionSeq_var &
-CORBA_OpDescriptionSeq_var::operator= (const CORBA_OpDescriptionSeq_var &p) // deep copy
+ACE_INLINE IR::ValueMemberSeq_var &
+IR::ValueMemberSeq_var::operator= (const ::IR::ValueMemberSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_OpDescriptionSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ValueMemberSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_OpDescriptionSeq *
-CORBA_OpDescriptionSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::ValueMemberSeq *
+IR::ValueMemberSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OpDescriptionSeq *
-CORBA_OpDescriptionSeq_var::operator-> (void)
+ACE_INLINE ::IR::ValueMemberSeq *
+IR::ValueMemberSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_OpDescriptionSeq_var::operator const CORBA_OpDescriptionSeq &() const // cast
+IR::ValueMemberSeq_var::operator const ::IR::ValueMemberSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_OpDescriptionSeq_var::operator CORBA_OpDescriptionSeq &() // cast 
+IR::ValueMemberSeq_var::operator ::IR::ValueMemberSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_OpDescriptionSeq_var::operator CORBA_OpDescriptionSeq &() const// cast 
+IR::ValueMemberSeq_var::operator ::IR::ValueMemberSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDescription &
-CORBA_OpDescriptionSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::ValueMemberSeq_var::operator ::IR::ValueMemberSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ValueMember &
+IR::ValueMemberSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_OpDescriptionSeq &
-CORBA_OpDescriptionSeq_var::in (void) const
+ACE_INLINE const ::IR::ValueMemberSeq &
+IR::ValueMemberSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_OpDescriptionSeq &
-CORBA_OpDescriptionSeq_var::inout (void)
+ACE_INLINE ::IR::ValueMemberSeq &
+IR::ValueMemberSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_OpDescriptionSeq *&
-CORBA_OpDescriptionSeq_var::out (void)
+ACE_INLINE ::IR::ValueMemberSeq *&
+IR::ValueMemberSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OpDescriptionSeq *
-CORBA_OpDescriptionSeq_var::_retn (void)
+ACE_INLINE ::IR::ValueMemberSeq *
+IR::ValueMemberSeq_var::_retn (void)
 {
-  CORBA_OpDescriptionSeq *tmp = this->ptr_;
+  ::IR::ValueMemberSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_OpDescriptionSeq *
-CORBA_OpDescriptionSeq_var::ptr (void) const
+ACE_INLINE ::IR::ValueMemberSeq *
+IR::ValueMemberSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_OpDescriptionSeq_out
+// Inline operations for class IR::ValueMemberSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_OpDescriptionSeq_out::CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq *&p)
+IR::ValueMemberSeq_out::ValueMemberSeq_out (ValueMemberSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_OpDescriptionSeq_out::CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq_var &p) // constructor from _var
+IR::ValueMemberSeq_out::ValueMemberSeq_out (ValueMemberSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -10416,44 +15380,44 @@ CORBA_OpDescriptionSeq_out::CORBA_OpDescriptionSeq_out (CORBA_OpDescriptionSeq_v
 }
 
 ACE_INLINE
-CORBA_OpDescriptionSeq_out::CORBA_OpDescriptionSeq_out (const CORBA_OpDescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_OpDescriptionSeq_out&,p).ptr_)
+IR::ValueMemberSeq_out::ValueMemberSeq_out (const ::IR::ValueMemberSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ValueMemberSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_OpDescriptionSeq_out &
-CORBA_OpDescriptionSeq_out::operator= (const CORBA_OpDescriptionSeq_out &p)
+ACE_INLINE ::IR::ValueMemberSeq_out &
+IR::ValueMemberSeq_out::operator= (const ::IR::ValueMemberSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_OpDescriptionSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ValueMemberSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_OpDescriptionSeq_out &
-CORBA_OpDescriptionSeq_out::operator= (CORBA_OpDescriptionSeq *p)
+ACE_INLINE ::IR::ValueMemberSeq_out &
+IR::ValueMemberSeq_out::operator= (ValueMemberSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_OpDescriptionSeq_out::operator CORBA_OpDescriptionSeq *&() // cast
+IR::ValueMemberSeq_out::operator ::IR::ValueMemberSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OpDescriptionSeq *&
-CORBA_OpDescriptionSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::ValueMemberSeq *&
+IR::ValueMemberSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OpDescriptionSeq *
-CORBA_OpDescriptionSeq_out::operator-> (void)
+ACE_INLINE ::IR::ValueMemberSeq *
+IR::ValueMemberSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_OperationDescription &
-CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE IR::ValueMember &
+IR::ValueMemberSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -10461,315 +15425,513 @@ CORBA_OpDescriptionSeq_out::operator[] (CORBA::ULong index)
 
 #endif /* end #if !defined */
 
+ACE_INLINE
+IR::ValueMemberDef::ValueMemberDef (void) // default constructor
+{}
 
-#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
-  
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CI_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_ATTRDESCRIPTIONSEQ_CI_
+ACE_INLINE
+IR::ValueMemberDef::ValueMemberDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
 
-  // = Static operations.
-  ACE_INLINE CORBA_AttributeDescription *
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (CORBA::ULong size)
-  // Allocate storage for the sequence.
-  {
-    CORBA_AttributeDescription *retval = 0;
-    ACE_NEW_RETURN (retval,
-                    CORBA_AttributeDescription[size],
-		    0);
-    return retval;
-  }
-  
-  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (CORBA_AttributeDescription *buffer)
-  // Free the sequence.
-  {
-    delete [] buffer;
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (void) // Default constructor.
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (maximum))
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (CORBA::ULong maximum,
-    CORBA::ULong length,
-    CORBA_AttributeDescription *data,
-    CORBA::Boolean release)
-  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
-  {
-  }
-  
-  ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::_TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
-  // Copy constructor.
-    : TAO_Unbounded_Base_Sequence (rhs)
-  {
-    CORBA_AttributeDescription *tmp1 = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (this->maximum_);
-    CORBA_AttributeDescription * const tmp2 = ACE_reinterpret_cast (CORBA_AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    this->buffer_ = tmp1;
-  }
-  
-  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq &rhs)
-  // Assignment operator.
-  {
-    if (this == &rhs)
-      return *this;
-    
-    if (this->release_)
-    {
-      if (this->maximum_ < rhs.maximum_)
-      {
-        // free the old buffer
-        CORBA_AttributeDescription *tmp = ACE_reinterpret_cast (CORBA_AttributeDescription *, this->buffer_);
-        _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (rhs.maximum_);
-      }
-    }
-    else
-      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (rhs.maximum_);
-    
-    TAO_Unbounded_Base_Sequence::operator= (rhs);
-    
-    CORBA_AttributeDescription *tmp1 = ACE_reinterpret_cast (CORBA_AttributeDescription *, this->buffer_);
-    CORBA_AttributeDescription * const tmp2 = ACE_reinterpret_cast (CORBA_AttributeDescription * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    return *this;
-  }
-  
-  // = Accessors.
-  ACE_INLINE CORBA_AttributeDescription &
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i)
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    CORBA_AttributeDescription* tmp = ACE_reinterpret_cast(CORBA_AttributeDescription*,this->buffer_);
-    return tmp[i];
-  }
-  
-  ACE_INLINE const CORBA_AttributeDescription &
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::operator[] (CORBA::ULong i) const
-  // operator []
-  {
-    ACE_ASSERT (i < this->maximum_);
-    CORBA_AttributeDescription * const tmp = ACE_reinterpret_cast (CORBA_AttributeDescription* ACE_CAST_CONST, this->buffer_);
-    return tmp[i];
-  }
-  
-  // Implement the TAO_Base_Sequence methods (see Sequence.h)
-  
-  ACE_INLINE CORBA_AttributeDescription *
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (CORBA::Boolean orphan)
-  {
-    CORBA_AttributeDescription *result = 0;
-    if (orphan == 0)
-    {
-      // We retain ownership.
-      if (this->buffer_ == 0)
-      {
-        result = _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::allocbuf (this->length_);
-        this->buffer_ = result;
-      }
-      else
-      {
-        result = ACE_reinterpret_cast (CORBA_AttributeDescription*, this->buffer_);
-      }
-    }
-    else // if (orphan == 1)
-    {
-      if (this->release_ != 0)
-      {
-        // We set the state back to default and relinquish
-        // ownership.
-        result = ACE_reinterpret_cast(CORBA_AttributeDescription*,this->buffer_);
-        this->maximum_ = 0;
-        this->length_ = 0;
-        this->buffer_ = 0;
-        this->release_ = 0;
-      }
-    }
-    return result;
-  }
-  
-  ACE_INLINE const CORBA_AttributeDescription *
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::get_buffer (void) const
+ACE_INLINE
+IR::ValueMemberDef::~ValueMemberDef (void) // destructor
+{}
+
+
+#if !defined (_IR_VALUEMEMBERDEF___VAR_CI_)
+#define _IR_VALUEMEMBERDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::ValueMemberDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::ValueMemberDef_var::ValueMemberDef_var (void) // default constructor
+  : ptr_ (ValueMemberDef::_nil ())
+{}
+
+ACE_INLINE
+IR::ValueMemberDef_var::ValueMemberDef_var (ValueMemberDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::ValueMemberDef_ptr
+IR::ValueMemberDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ValueMemberDef_var::ValueMemberDef_var (const ::IR::ValueMemberDef_var &p) // copy constructor
+  : ptr_ (ValueMemberDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ValueMemberDef_var::~ValueMemberDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ValueMemberDef_var &
+IR::ValueMemberDef_var::operator= (ValueMemberDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ValueMemberDef_var &
+IR::ValueMemberDef_var::operator= (const ::IR::ValueMemberDef_var &p)
+{
+  if (this != &p)
   {
-    return ACE_reinterpret_cast(const CORBA_AttributeDescription * ACE_CAST_CONST, this->buffer_);
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::ValueMemberDef::_duplicate (p.ptr ());
   }
-  
-  ACE_INLINE void
-  _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::replace (CORBA::ULong max,
-  CORBA::ULong length,
-  CORBA_AttributeDescription *data,
-  CORBA::Boolean release)
+  return *this;
+}
+
+ACE_INLINE 
+IR::ValueMemberDef_var::operator const ::IR::ValueMemberDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ValueMemberDef_var::operator ::IR::ValueMemberDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueMemberDef_ptr
+IR::ValueMemberDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueMemberDef_ptr
+IR::ValueMemberDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueMemberDef_ptr &
+IR::ValueMemberDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueMemberDef_ptr &
+IR::ValueMemberDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ValueMemberDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueMemberDef_ptr
+IR::ValueMemberDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::ValueMemberDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ValueMemberDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_VALUEMEMBERDEF___OUT_CI_)
+#define _IR_VALUEMEMBERDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ValueMemberDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::ValueMemberDef_out::ValueMemberDef_out (ValueMemberDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::ValueMemberDef::_nil ();
+}
+
+ACE_INLINE
+IR::ValueMemberDef_out::ValueMemberDef_out (ValueMemberDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ValueMemberDef::_nil ();
+}
+
+ACE_INLINE
+IR::ValueMemberDef_out::ValueMemberDef_out (const ::IR::ValueMemberDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ValueMemberDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ValueMemberDef_out &
+IR::ValueMemberDef_out::operator= (const ::IR::ValueMemberDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (ValueMemberDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ValueMemberDef_out &
+IR::ValueMemberDef_out::operator= (const ::IR::ValueMemberDef_var &p)
+{
+  this->ptr_ = ::IR::ValueMemberDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ValueMemberDef_out &
+IR::ValueMemberDef_out::operator= (ValueMemberDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ValueMemberDef_out::operator ::IR::ValueMemberDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueMemberDef_ptr &
+IR::ValueMemberDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueMemberDef_ptr
+IR::ValueMemberDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+ACE_INLINE
+IR::ValueDef::ValueDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::ValueDef::ValueDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::ValueDef::~ValueDef (void) // destructor
+{}
+
+
+#if !defined (_IR_VALUEDEF___VAR_CI_)
+#define _IR_VALUEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::ValueDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::ValueDef_var::ValueDef_var (void) // default constructor
+  : ptr_ (ValueDef::_nil ())
+{}
+
+ACE_INLINE
+IR::ValueDef_var::ValueDef_var (ValueDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::ValueDef_ptr
+IR::ValueDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ValueDef_var::ValueDef_var (const ::IR::ValueDef_var &p) // copy constructor
+  : ptr_ (ValueDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ValueDef_var::~ValueDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ValueDef_var &
+IR::ValueDef_var::operator= (ValueDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ValueDef_var &
+IR::ValueDef_var::operator= (const ::IR::ValueDef_var &p)
+{
+  if (this != &p)
   {
-    this->maximum_ = max;
-    this->length_ = length;
-    if (this->buffer_ && this->release_ == 1)
-    {
-      CORBA_AttributeDescription *tmp = ACE_reinterpret_cast(CORBA_AttributeDescription*,this->buffer_);
-      _TAO_Unbounded_Sequence_CORBA_AttrDescriptionSeq::freebuf (tmp);
-    }
-    this->buffer_ = data;
-    this->release_ = release;
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::ValueDef::_duplicate (p.ptr ());
   }
-  
+  return *this;
+}
+
+ACE_INLINE 
+IR::ValueDef_var::operator const ::IR::ValueDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ValueDef_var::operator ::IR::ValueDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDef_ptr
+IR::ValueDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDef_ptr
+IR::ValueDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDef_ptr &
+IR::ValueDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDef_ptr &
+IR::ValueDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ValueDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDef_ptr
+IR::ValueDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::ValueDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ValueDef::_nil ();
+  return val;
+}
+
+
 #endif /* end #if !defined */
 
 
-#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+#if !defined (_IR_VALUEDEF___OUT_CI_)
+#define _IR_VALUEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ValueDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::ValueDef_out::ValueDef_out (ValueDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::ValueDef::_nil ();
+}
+
+ACE_INLINE
+IR::ValueDef_out::ValueDef_out (ValueDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ValueDef::_nil ();
+}
+
+ACE_INLINE
+IR::ValueDef_out::ValueDef_out (const ::IR::ValueDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ValueDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ValueDef_out &
+IR::ValueDef_out::operator= (const ::IR::ValueDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (ValueDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ValueDef_out &
+IR::ValueDef_out::operator= (const ::IR::ValueDef_var &p)
+{
+  this->ptr_ = ::IR::ValueDef::_duplicate (p.ptr ());
+  return *this;
+}
 
-#if !defined (_CORBA_ATTRDESCRIPTIONSEQ_CI_)
-#define _CORBA_ATTRDESCRIPTIONSEQ_CI_
+ACE_INLINE IR::ValueDef_out &
+IR::ValueDef_out::operator= (ValueDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ValueDef_out::operator ::IR::ValueDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDef_ptr &
+IR::ValueDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueDef_ptr
+IR::ValueDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA_AttrDescriptionSeq_var
+// Inline operations for class IR::ValueDescription_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_AttrDescriptionSeq_var::CORBA_AttrDescriptionSeq_var (void) // default constructor
+IR::ValueDescription_var::ValueDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_AttrDescriptionSeq_var::CORBA_AttrDescriptionSeq_var (CORBA_AttrDescriptionSeq *p)
+IR::ValueDescription_var::ValueDescription_var (ValueDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_AttrDescriptionSeq_var::CORBA_AttrDescriptionSeq_var (const CORBA_AttrDescriptionSeq_var &p) // copy constructor
+IR::ValueDescription_var::ValueDescription_var (const ::IR::ValueDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_AttrDescriptionSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ValueDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_AttrDescriptionSeq_var::~CORBA_AttrDescriptionSeq_var (void) // destructor
+IR::ValueDescription_var::~ValueDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_AttrDescriptionSeq_var &
-CORBA_AttrDescriptionSeq_var::operator= (CORBA_AttrDescriptionSeq *p)
+ACE_INLINE IR::ValueDescription_var &
+IR::ValueDescription_var::operator= (ValueDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_AttrDescriptionSeq_var &
-CORBA_AttrDescriptionSeq_var::operator= (const CORBA_AttrDescriptionSeq_var &p) // deep copy
+ACE_INLINE ::IR::ValueDescription_var &
+IR::ValueDescription_var::operator= (const ::IR::ValueDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_AttrDescriptionSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ValueDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_AttrDescriptionSeq *
-CORBA_AttrDescriptionSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::ValueDescription *
+IR::ValueDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttrDescriptionSeq *
-CORBA_AttrDescriptionSeq_var::operator-> (void)
+ACE_INLINE ::IR::ValueDescription *
+IR::ValueDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_AttrDescriptionSeq_var::operator const CORBA_AttrDescriptionSeq &() const // cast
+ACE_INLINE
+IR::ValueDescription_var::operator const ::IR::ValueDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_AttrDescriptionSeq_var::operator CORBA_AttrDescriptionSeq &() // cast 
+ACE_INLINE
+IR::ValueDescription_var::operator ::IR::ValueDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_AttrDescriptionSeq_var::operator CORBA_AttrDescriptionSeq &() const// cast 
+ACE_INLINE
+IR::ValueDescription_var::operator ::IR::ValueDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDescription &
-CORBA_AttrDescriptionSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::ValueDescription_var::operator ::IR::ValueDescription *&() // cast 
 {
-  return this->ptr_->operator[] (index);
+  return this->ptr_;
 }
 
-ACE_INLINE const CORBA_AttrDescriptionSeq &
-CORBA_AttrDescriptionSeq_var::in (void) const
+ACE_INLINE const ::IR::ValueDescription &
+IR::ValueDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_AttrDescriptionSeq &
-CORBA_AttrDescriptionSeq_var::inout (void)
+ACE_INLINE ::IR::ValueDescription &
+IR::ValueDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_AttrDescriptionSeq *&
-CORBA_AttrDescriptionSeq_var::out (void)
+ACE_INLINE ::IR::ValueDescription *&
+IR::ValueDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttrDescriptionSeq *
-CORBA_AttrDescriptionSeq_var::_retn (void)
+ACE_INLINE ::IR::ValueDescription *
+IR::ValueDescription_var::_retn (void)
 {
-  CORBA_AttrDescriptionSeq *tmp = this->ptr_;
+  ::IR::ValueDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_AttrDescriptionSeq *
-CORBA_AttrDescriptionSeq_var::ptr (void) const
+ACE_INLINE ::IR::ValueDescription *
+IR::ValueDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_AttrDescriptionSeq_out
+// Inline operations for class IR::ValueDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_AttrDescriptionSeq_out::CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptionSeq *&p)
+IR::ValueDescription_out::ValueDescription_out (::IR::ValueDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_AttrDescriptionSeq_out::CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptionSeq_var &p) // constructor from _var
+IR::ValueDescription_out::ValueDescription_out (ValueDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -10777,162 +15939,340 @@ CORBA_AttrDescriptionSeq_out::CORBA_AttrDescriptionSeq_out (CORBA_AttrDescriptio
 }
 
 ACE_INLINE
-CORBA_AttrDescriptionSeq_out::CORBA_AttrDescriptionSeq_out (const CORBA_AttrDescriptionSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_AttrDescriptionSeq_out&,p).ptr_)
+IR::ValueDescription_out::ValueDescription_out (const ::IR::ValueDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ValueDescription_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_AttrDescriptionSeq_out &
-CORBA_AttrDescriptionSeq_out::operator= (const CORBA_AttrDescriptionSeq_out &p)
+ACE_INLINE IR::ValueDescription_out &
+IR::ValueDescription_out::operator= (const ::IR::ValueDescription_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_AttrDescriptionSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ValueDescription_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_AttrDescriptionSeq_out &
-CORBA_AttrDescriptionSeq_out::operator= (CORBA_AttrDescriptionSeq *p)
+ACE_INLINE IR::ValueDescription_out &
+IR::ValueDescription_out::operator= (ValueDescription *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_AttrDescriptionSeq_out::operator CORBA_AttrDescriptionSeq *&() // cast
+IR::ValueDescription_out::operator ::IR::ValueDescription *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttrDescriptionSeq *&
-CORBA_AttrDescriptionSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::ValueDescription *&
+IR::ValueDescription_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttrDescriptionSeq *
-CORBA_AttrDescriptionSeq_out::operator-> (void)
+ACE_INLINE ::IR::ValueDescription *
+IR::ValueDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ValueBoxDef::ValueBoxDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::ValueBoxDef::ValueBoxDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::ValueBoxDef::~ValueBoxDef (void) // destructor
+{}
+
+
+#if !defined (_IR_VALUEBOXDEF___VAR_CI_)
+#define _IR_VALUEBOXDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::ValueBoxDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::ValueBoxDef_var::ValueBoxDef_var (void) // default constructor
+  : ptr_ (ValueBoxDef::_nil ())
+{}
+
+ACE_INLINE
+IR::ValueBoxDef_var::ValueBoxDef_var (ValueBoxDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::ValueBoxDef_ptr
+IR::ValueBoxDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_AttributeDescription &
-CORBA_AttrDescriptionSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE
+IR::ValueBoxDef_var::ValueBoxDef_var (const ::IR::ValueBoxDef_var &p) // copy constructor
+  : ptr_ (ValueBoxDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ValueBoxDef_var::~ValueBoxDef_var (void) // destructor
 {
-  return this->ptr_->operator[] (index);
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ValueBoxDef_var &
+IR::ValueBoxDef_var::operator= (ValueBoxDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ValueBoxDef_var &
+IR::ValueBoxDef_var::operator= (const ::IR::ValueBoxDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::ValueBoxDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::ValueBoxDef_var::operator const ::IR::ValueBoxDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ValueBoxDef_var::operator ::IR::ValueBoxDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueBoxDef_ptr
+IR::ValueBoxDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueBoxDef_ptr
+IR::ValueBoxDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueBoxDef_ptr &
+IR::ValueBoxDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueBoxDef_ptr &
+IR::ValueBoxDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ValueBoxDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueBoxDef_ptr
+IR::ValueBoxDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::ValueBoxDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ValueBoxDef::_nil ();
+  return val;
 }
 
 
 #endif /* end #if !defined */
 
+
+#if !defined (_IR_VALUEBOXDEF___OUT_CI_)
+#define _IR_VALUEBOXDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ValueBoxDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::ValueBoxDef_out::ValueBoxDef_out (ValueBoxDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::ValueBoxDef::_nil ();
+}
+
 ACE_INLINE
-CORBA_InterfaceDef::CORBA_InterfaceDef (void) // default constructor
+IR::ValueBoxDef_out::ValueBoxDef_out (ValueBoxDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ValueBoxDef::_nil ();
+}
+
+ACE_INLINE
+IR::ValueBoxDef_out::ValueBoxDef_out (const ::IR::ValueBoxDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ValueBoxDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ValueBoxDef_out &
+IR::ValueBoxDef_out::operator= (const ::IR::ValueBoxDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (ValueBoxDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ValueBoxDef_out &
+IR::ValueBoxDef_out::operator= (const ::IR::ValueBoxDef_var &p)
+{
+  this->ptr_ = ::IR::ValueBoxDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ValueBoxDef_out &
+IR::ValueBoxDef_out::operator= (ValueBoxDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ValueBoxDef_out::operator ::IR::ValueBoxDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueBoxDef_ptr &
+IR::ValueBoxDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ValueBoxDef_ptr
+IR::ValueBoxDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+ACE_INLINE
+IR::ProvidesDef::ProvidesDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_InterfaceDef::CORBA_InterfaceDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::ProvidesDef::ProvidesDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_InterfaceDef::~CORBA_InterfaceDef (void) // destructor
+IR::ProvidesDef::~ProvidesDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_INTERFACEDEF___VAR_CI_)
-#define _CORBA_INTERFACEDEF___VAR_CI_
+#if !defined (_IR_PROVIDESDEF___VAR_CI_)
+#define _IR_PROVIDESDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_InterfaceDef_var
+// Inline operations for class IR::ProvidesDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_InterfaceDef_var::CORBA_InterfaceDef_var (void) // default constructor
-  : ptr_ (CORBA_InterfaceDef::_nil ())
+IR::ProvidesDef_var::ProvidesDef_var (void) // default constructor
+  : ptr_ (ProvidesDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_InterfaceDef_var::CORBA_InterfaceDef_var (CORBA_InterfaceDef_ptr p)
+IR::ProvidesDef_var::ProvidesDef_var (ProvidesDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_InterfaceDef_ptr 
-CORBA_InterfaceDef_var::ptr (void) const
+ACE_INLINE ::IR::ProvidesDef_ptr
+IR::ProvidesDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_InterfaceDef_var::CORBA_InterfaceDef_var (const CORBA_InterfaceDef_var &p) // copy constructor
-  : ptr_ (CORBA_InterfaceDef::_duplicate (p.ptr ()))
+IR::ProvidesDef_var::ProvidesDef_var (const ::IR::ProvidesDef_var &p) // copy constructor
+  : ptr_ (ProvidesDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_InterfaceDef_var::~CORBA_InterfaceDef_var (void) // destructor
+IR::ProvidesDef_var::~ProvidesDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_InterfaceDef_var &
-CORBA_InterfaceDef_var::operator= (CORBA_InterfaceDef_ptr p)
+ACE_INLINE IR::ProvidesDef_var &
+IR::ProvidesDef_var::operator= (ProvidesDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_InterfaceDef_var &
-CORBA_InterfaceDef_var::operator= (const CORBA_InterfaceDef_var &p)
+ACE_INLINE IR::ProvidesDef_var &
+IR::ProvidesDef_var::operator= (const ::IR::ProvidesDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_InterfaceDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::ProvidesDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_InterfaceDef_var::operator const CORBA_InterfaceDef_ptr &() const // cast
+IR::ProvidesDef_var::operator const ::IR::ProvidesDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_InterfaceDef_var::operator CORBA_InterfaceDef_ptr &() // cast 
+IR::ProvidesDef_var::operator ::IR::ProvidesDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef_ptr 
-CORBA_InterfaceDef_var::operator-> (void) const
+ACE_INLINE ::IR::ProvidesDef_ptr
+IR::ProvidesDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef_ptr
-CORBA_InterfaceDef_var::in (void) const
+ACE_INLINE ::IR::ProvidesDef_ptr
+IR::ProvidesDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef_ptr &
-CORBA_InterfaceDef_var::inout (void)
+ACE_INLINE ::IR::ProvidesDef_ptr &
+IR::ProvidesDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef_ptr &
-CORBA_InterfaceDef_var::out (void)
+ACE_INLINE ::IR::ProvidesDef_ptr &
+IR::ProvidesDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_InterfaceDef::_nil ();
+  this->ptr_ = ::IR::ProvidesDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef_ptr 
-CORBA_InterfaceDef_var::_retn (void)
+ACE_INLINE ::IR::ProvidesDef_ptr
+IR::ProvidesDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_InterfaceDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_InterfaceDef::_nil ();
+  ::IR::ProvidesDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ProvidesDef::_nil ();
   return val;
 }
 
@@ -10940,68 +16280,68 @@ CORBA_InterfaceDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_INTERFACEDEF___OUT_CI_)
-#define _CORBA_INTERFACEDEF___OUT_CI_
+#if !defined (_IR_PROVIDESDEF___OUT_CI_)
+#define _IR_PROVIDESDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_InterfaceDef_out
+// Inline operations for class IR::ProvidesDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_InterfaceDef_out::CORBA_InterfaceDef_out (CORBA_InterfaceDef_ptr &p)
+IR::ProvidesDef_out::ProvidesDef_out (ProvidesDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_InterfaceDef::_nil ();
+  this->ptr_ = ::IR::ProvidesDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_InterfaceDef_out::CORBA_InterfaceDef_out (CORBA_InterfaceDef_var &p) // constructor from _var
+IR::ProvidesDef_out::ProvidesDef_out (ProvidesDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_InterfaceDef::_nil ();
+  this->ptr_ = ::IR::ProvidesDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_InterfaceDef_out::CORBA_InterfaceDef_out (const CORBA_InterfaceDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_InterfaceDef_out&,p).ptr_)
+IR::ProvidesDef_out::ProvidesDef_out (const ::IR::ProvidesDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ProvidesDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_InterfaceDef_out &
-CORBA_InterfaceDef_out::operator= (const CORBA_InterfaceDef_out &p)
+ACE_INLINE ::IR::ProvidesDef_out &
+IR::ProvidesDef_out::operator= (const ::IR::ProvidesDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_InterfaceDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ProvidesDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_InterfaceDef_out &
-CORBA_InterfaceDef_out::operator= (const CORBA_InterfaceDef_var &p)
+ACE_INLINE IR::ProvidesDef_out &
+IR::ProvidesDef_out::operator= (const ::IR::ProvidesDef_var &p)
 {
-  this->ptr_ = CORBA_InterfaceDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::ProvidesDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_InterfaceDef_out &
-CORBA_InterfaceDef_out::operator= (CORBA_InterfaceDef_ptr p)
+ACE_INLINE IR::ProvidesDef_out &
+IR::ProvidesDef_out::operator= (ProvidesDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_InterfaceDef_out::operator CORBA_InterfaceDef_ptr &() // cast
+IR::ProvidesDef_out::operator ::IR::ProvidesDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef_ptr &
-CORBA_InterfaceDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::ProvidesDef_ptr &
+IR::ProvidesDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef_ptr 
-CORBA_InterfaceDef_out::operator-> (void)
+ACE_INLINE ::IR::ProvidesDef_ptr
+IR::ProvidesDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -11010,134 +16350,138 @@ CORBA_InterfaceDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 // *************************************************************
-// Inline operations for class CORBA_InterfaceDef::FullInterfaceDescription_var
+// Inline operations for class IR::ProvidesDescription_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_InterfaceDef::FullInterfaceDescription_var::FullInterfaceDescription_var (void) // default constructor
+IR::ProvidesDescription_var::ProvidesDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_InterfaceDef::FullInterfaceDescription_var::FullInterfaceDescription_var (CORBA_InterfaceDef::FullInterfaceDescription *p)
+IR::ProvidesDescription_var::ProvidesDescription_var (ProvidesDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_InterfaceDef::FullInterfaceDescription_var::FullInterfaceDescription_var (const CORBA_InterfaceDef::FullInterfaceDescription_var &p) // copy constructor
+IR::ProvidesDescription_var::ProvidesDescription_var (const ::IR::ProvidesDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_InterfaceDef::FullInterfaceDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ProvidesDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_InterfaceDef::FullInterfaceDescription_var::~FullInterfaceDescription_var (void) // destructor
+IR::ProvidesDescription_var::~ProvidesDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription_var &
-CORBA_InterfaceDef::FullInterfaceDescription_var::operator= (CORBA_InterfaceDef::FullInterfaceDescription *p)
+ACE_INLINE IR::ProvidesDescription_var &
+IR::ProvidesDescription_var::operator= (ProvidesDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription_var &
-CORBA_InterfaceDef::FullInterfaceDescription_var::operator= (const CORBA_InterfaceDef::FullInterfaceDescription_var &p)
+ACE_INLINE ::IR::ProvidesDescription_var &
+IR::ProvidesDescription_var::operator= (const ::IR::ProvidesDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_InterfaceDef::FullInterfaceDescription (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ProvidesDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_InterfaceDef::FullInterfaceDescription *
-CORBA_InterfaceDef::FullInterfaceDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::ProvidesDescription *
+IR::ProvidesDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *
-CORBA_InterfaceDef::FullInterfaceDescription_var::operator-> (void)
+ACE_INLINE ::IR::ProvidesDescription *
+IR::ProvidesDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_InterfaceDef::FullInterfaceDescription_var::operator const CORBA_InterfaceDef::FullInterfaceDescription &() const // cast
+ACE_INLINE
+IR::ProvidesDescription_var::operator const ::IR::ProvidesDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_InterfaceDef::FullInterfaceDescription_var::operator CORBA_InterfaceDef::FullInterfaceDescription &() // cast 
+ACE_INLINE
+IR::ProvidesDescription_var::operator ::IR::ProvidesDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_InterfaceDef::FullInterfaceDescription_var::operator CORBA_InterfaceDef::FullInterfaceDescription &() const// cast 
+ACE_INLINE
+IR::ProvidesDescription_var::operator ::IR::ProvidesDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_InterfaceDef::FullInterfaceDescription &
-CORBA_InterfaceDef::FullInterfaceDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::ProvidesDescription_var::operator ::IR::ProvidesDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::ProvidesDescription &
+IR::ProvidesDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription &
-CORBA_InterfaceDef::FullInterfaceDescription_var::inout (void)
+ACE_INLINE ::IR::ProvidesDescription &
+IR::ProvidesDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *&
-CORBA_InterfaceDef::FullInterfaceDescription_var::out (void)
+ACE_INLINE ::IR::ProvidesDescription *&
+IR::ProvidesDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *
-CORBA_InterfaceDef::FullInterfaceDescription_var::_retn (void)
+ACE_INLINE ::IR::ProvidesDescription *
+IR::ProvidesDescription_var::_retn (void)
 {
-  CORBA_InterfaceDef::FullInterfaceDescription *tmp = this->ptr_;
+  ::IR::ProvidesDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *
-CORBA_InterfaceDef::FullInterfaceDescription_var::ptr (void) const
+ACE_INLINE ::IR::ProvidesDescription *
+IR::ProvidesDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_InterfaceDef::FullInterfaceDescription_out
+// Inline operations for class IR::ProvidesDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_InterfaceDef::FullInterfaceDescription_out::FullInterfaceDescription_out (CORBA_InterfaceDef::FullInterfaceDescription *&p)
+IR::ProvidesDescription_out::ProvidesDescription_out (::IR::ProvidesDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_InterfaceDef::FullInterfaceDescription_out::FullInterfaceDescription_out (CORBA_InterfaceDef::FullInterfaceDescription_var &p) // constructor from _var
+IR::ProvidesDescription_out::ProvidesDescription_out (ProvidesDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -11145,171 +16489,362 @@ CORBA_InterfaceDef::FullInterfaceDescription_out::FullInterfaceDescription_out (
 }
 
 ACE_INLINE
-CORBA_InterfaceDef::FullInterfaceDescription_out::FullInterfaceDescription_out (const CORBA_InterfaceDef::FullInterfaceDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_InterfaceDef::FullInterfaceDescription_out&,p).ptr_)
+IR::ProvidesDescription_out::ProvidesDescription_out (const ::IR::ProvidesDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ProvidesDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::ProvidesDescription_out &
+IR::ProvidesDescription_out::operator= (const ::IR::ProvidesDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (ProvidesDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ProvidesDescription_out &
+IR::ProvidesDescription_out::operator= (ProvidesDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ProvidesDescription_out::operator ::IR::ProvidesDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescription *&
+IR::ProvidesDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ProvidesDescription *
+IR::ProvidesDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::UsesDef::UsesDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::UsesDef::UsesDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::UsesDef::~UsesDef (void) // destructor
+{}
+
+
+#if !defined (_IR_USESDEF___VAR_CI_)
+#define _IR_USESDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::UsesDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDef_var::UsesDef_var (void) // default constructor
+  : ptr_ (UsesDef::_nil ())
+{}
+
+ACE_INLINE
+IR::UsesDef_var::UsesDef_var (UsesDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::UsesDef_ptr
+IR::UsesDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::UsesDef_var::UsesDef_var (const ::IR::UsesDef_var &p) // copy constructor
+  : ptr_ (UsesDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::UsesDef_var::~UsesDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::UsesDef_var &
+IR::UsesDef_var::operator= (UsesDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::UsesDef_var &
+IR::UsesDef_var::operator= (const ::IR::UsesDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::UsesDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::UsesDef_var::operator const ::IR::UsesDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::UsesDef_var::operator ::IR::UsesDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDef_ptr
+IR::UsesDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDef_ptr
+IR::UsesDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDef_ptr &
+IR::UsesDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDef_ptr &
+IR::UsesDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::UsesDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::UsesDef_ptr
+IR::UsesDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::UsesDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::UsesDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_USESDEF___OUT_CI_)
+#define _IR_USESDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::UsesDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::UsesDef_out::UsesDef_out (UsesDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::UsesDef::_nil ();
+}
+
+ACE_INLINE
+IR::UsesDef_out::UsesDef_out (UsesDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::UsesDef::_nil ();
+}
+
+ACE_INLINE
+IR::UsesDef_out::UsesDef_out (const ::IR::UsesDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UsesDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription_out &
-CORBA_InterfaceDef::FullInterfaceDescription_out::operator= (const CORBA_InterfaceDef::FullInterfaceDescription_out &p)
+ACE_INLINE ::IR::UsesDef_out &
+IR::UsesDef_out::operator= (const ::IR::UsesDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_InterfaceDef::FullInterfaceDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (UsesDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription_out &
-CORBA_InterfaceDef::FullInterfaceDescription_out::operator= (CORBA_InterfaceDef::FullInterfaceDescription *p)
+ACE_INLINE IR::UsesDef_out &
+IR::UsesDef_out::operator= (const ::IR::UsesDef_var &p)
+{
+  this->ptr_ = ::IR::UsesDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::UsesDef_out &
+IR::UsesDef_out::operator= (UsesDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_InterfaceDef::FullInterfaceDescription_out::operator CORBA_InterfaceDef::FullInterfaceDescription *&() // cast
+IR::UsesDef_out::operator ::IR::UsesDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *&
-CORBA_InterfaceDef::FullInterfaceDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::UsesDef_ptr &
+IR::UsesDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDef::FullInterfaceDescription *
-CORBA_InterfaceDef::FullInterfaceDescription_out::operator-> (void)
+ACE_INLINE ::IR::UsesDef_ptr
+IR::UsesDef_out::operator-> (void)
 {
   return this->ptr_;
 }
 
+
+#endif /* end #if !defined */
+
 // *************************************************************
-// Inline operations for class CORBA_InterfaceDescription_var
+// Inline operations for class IR::UsesDescription_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_InterfaceDescription_var::CORBA_InterfaceDescription_var (void) // default constructor
+IR::UsesDescription_var::UsesDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_InterfaceDescription_var::CORBA_InterfaceDescription_var (CORBA_InterfaceDescription *p)
+IR::UsesDescription_var::UsesDescription_var (UsesDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_InterfaceDescription_var::CORBA_InterfaceDescription_var (const CORBA_InterfaceDescription_var &p) // copy constructor
+IR::UsesDescription_var::UsesDescription_var (const ::IR::UsesDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_InterfaceDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::UsesDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_InterfaceDescription_var::~CORBA_InterfaceDescription_var (void) // destructor
+IR::UsesDescription_var::~UsesDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDescription_var &
-CORBA_InterfaceDescription_var::operator= (CORBA_InterfaceDescription *p)
+ACE_INLINE IR::UsesDescription_var &
+IR::UsesDescription_var::operator= (UsesDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_InterfaceDescription_var &
-CORBA_InterfaceDescription_var::operator= (const CORBA_InterfaceDescription_var &p)
+ACE_INLINE ::IR::UsesDescription_var &
+IR::UsesDescription_var::operator= (const ::IR::UsesDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_InterfaceDescription (*p.ptr_),
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::UsesDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_InterfaceDescription *
-CORBA_InterfaceDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::UsesDescription *
+IR::UsesDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDescription *
-CORBA_InterfaceDescription_var::operator-> (void)
+ACE_INLINE ::IR::UsesDescription *
+IR::UsesDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_InterfaceDescription_var::operator const CORBA_InterfaceDescription &() const // cast
+ACE_INLINE
+IR::UsesDescription_var::operator const ::IR::UsesDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_InterfaceDescription_var::operator CORBA_InterfaceDescription &() // cast 
+ACE_INLINE
+IR::UsesDescription_var::operator ::IR::UsesDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_InterfaceDescription_var::operator CORBA_InterfaceDescription &() const// cast 
+ACE_INLINE
+IR::UsesDescription_var::operator ::IR::UsesDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_InterfaceDescription &
-CORBA_InterfaceDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::UsesDescription_var::operator ::IR::UsesDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::UsesDescription &
+IR::UsesDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDescription &
-CORBA_InterfaceDescription_var::inout (void)
+ACE_INLINE ::IR::UsesDescription &
+IR::UsesDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_InterfaceDescription *&
-CORBA_InterfaceDescription_var::out (void)
+ACE_INLINE ::IR::UsesDescription *&
+IR::UsesDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDescription *
-CORBA_InterfaceDescription_var::_retn (void)
+ACE_INLINE ::IR::UsesDescription *
+IR::UsesDescription_var::_retn (void)
 {
-  CORBA_InterfaceDescription *tmp = this->ptr_;
+  ::IR::UsesDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_InterfaceDescription *
-CORBA_InterfaceDescription_var::ptr (void) const
+ACE_INLINE ::IR::UsesDescription *
+IR::UsesDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_InterfaceDescription_out
+// Inline operations for class IR::UsesDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_InterfaceDescription_out::CORBA_InterfaceDescription_out (CORBA_InterfaceDescription *&p)
+IR::UsesDescription_out::UsesDescription_out (::IR::UsesDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_InterfaceDescription_out::CORBA_InterfaceDescription_out (CORBA_InterfaceDescription_var &p) // constructor from _var
+IR::UsesDescription_out::UsesDescription_out (UsesDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -11317,171 +16852,360 @@ CORBA_InterfaceDescription_out::CORBA_InterfaceDescription_out (CORBA_InterfaceD
 }
 
 ACE_INLINE
-CORBA_InterfaceDescription_out::CORBA_InterfaceDescription_out (const CORBA_InterfaceDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_InterfaceDescription_out&,p).ptr_)
+IR::UsesDescription_out::UsesDescription_out (const ::IR::UsesDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UsesDescription_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_InterfaceDescription_out &
-CORBA_InterfaceDescription_out::operator= (const CORBA_InterfaceDescription_out &p)
+ACE_INLINE IR::UsesDescription_out &
+IR::UsesDescription_out::operator= (const ::IR::UsesDescription_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_InterfaceDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (UsesDescription_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_InterfaceDescription_out &
-CORBA_InterfaceDescription_out::operator= (CORBA_InterfaceDescription *p)
+ACE_INLINE IR::UsesDescription_out &
+IR::UsesDescription_out::operator= (UsesDescription *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_InterfaceDescription_out::operator CORBA_InterfaceDescription *&() // cast
+IR::UsesDescription_out::operator ::IR::UsesDescription *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDescription *&
-CORBA_InterfaceDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::UsesDescription *&
+IR::UsesDescription_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_InterfaceDescription *
-CORBA_InterfaceDescription_out::operator-> (void)
+ACE_INLINE ::IR::UsesDescription *
+IR::UsesDescription_out::operator-> (void)
 {
   return this->ptr_;
 }
 
+
+#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
+  
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_PROVIDESDESCSEQ_CI_
+
+  // = Static operations.
+  ACE_INLINE IR::ProvidesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (CORBA::ULong size)
+  // Allocate storage for the sequence.
+  {
+    IR::ProvidesDescription *retval = 0;
+    ACE_NEW_RETURN (retval, IR::ProvidesDescription[size], 0);
+    return retval;
+  }
+  
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (IR::ProvidesDescription *buffer)
+  // Free the sequence.
+  {
+    delete [] buffer;
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (void) // Default constructor.
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (maximum))
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (CORBA::ULong maximum,
+    CORBA::ULong length,
+    IR::ProvidesDescription *data,
+    CORBA::Boolean release)
+  : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
+  {
+  }
+  
+  ACE_INLINE
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs)
+  // Copy constructor.
+    : TAO_Unbounded_Base_Sequence (rhs)
+  {
+    if (rhs.buffer_ != 0)
+    {
+      IR::ProvidesDescription *tmp1 = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (this->maximum_);
+      IR::ProvidesDescription * const tmp2 = ACE_reinterpret_cast (IR::ProvidesDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
+  }
+  
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq &
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::operator= (const _TAO_Unbounded_Sequence_IR_ProvidesDescSeq &rhs)
+  // Assignment operator.
+  {
+    if (this == &rhs)
+      return *this;
+    
+    if (this->release_)
+    {
+      if (this->maximum_ < rhs.maximum_)
+      {
+        // free the old buffer
+        IR::ProvidesDescription *tmp = ACE_reinterpret_cast (IR::ProvidesDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (rhs.maximum_);
+      }
+    }
+    else
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (rhs.maximum_);
+    
+    TAO_Unbounded_Base_Sequence::operator= (rhs);
+    
+    IR::ProvidesDescription *tmp1 = ACE_reinterpret_cast (IR::ProvidesDescription *, this->buffer_);
+    IR::ProvidesDescription * const tmp2 = ACE_reinterpret_cast (IR::ProvidesDescription * ACE_CAST_CONST, rhs.buffer_);
+    
+    for (CORBA::ULong i = 0; i < this->length_; ++i)
+      tmp1[i] = tmp2[i];
+    
+    return *this;
+  }
+  
+  // = Accessors.
+  ACE_INLINE IR::ProvidesDescription &
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::operator[] (CORBA::ULong i)
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    IR::ProvidesDescription* tmp = ACE_reinterpret_cast(IR::ProvidesDescription*,this->buffer_);
+    return tmp[i];
+  }
+  
+  ACE_INLINE const IR::ProvidesDescription &
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::operator[] (CORBA::ULong i) const
+  // operator []
+  {
+    ACE_ASSERT (i < this->maximum_);
+    IR::ProvidesDescription * const tmp = ACE_reinterpret_cast (IR::ProvidesDescription* ACE_CAST_CONST, this->buffer_);
+    return tmp[i];
+  }
+  
+  // Implement the TAO_Base_Sequence methods (see Sequence.h)
+  
+  ACE_INLINE IR::ProvidesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::get_buffer (CORBA::Boolean orphan)
+  {
+    IR::ProvidesDescription *result = 0;
+    if (orphan == 0)
+    {
+      // We retain ownership.
+      if (this->buffer_ == 0)
+      {
+        result = _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::allocbuf (this->length_);
+        this->buffer_ = result;
+      }
+      else
+      {
+        result = ACE_reinterpret_cast (IR::ProvidesDescription*, this->buffer_);
+      }
+    }
+    else // if (orphan == 1)
+    {
+      if (this->release_ != 0)
+      {
+        // We set the state back to default and relinquish
+        // ownership.
+        result = ACE_reinterpret_cast(IR::ProvidesDescription*,this->buffer_);
+        this->maximum_ = 0;
+        this->length_ = 0;
+        this->buffer_ = 0;
+        this->release_ = 0;
+      }
+    }
+    return result;
+  }
+  
+  ACE_INLINE const IR::ProvidesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::get_buffer (void) const
+  {
+    return ACE_reinterpret_cast(const IR::ProvidesDescription * ACE_CAST_CONST, this->buffer_);
+  }
+  
+  ACE_INLINE void
+  IR::_TAO_Unbounded_Sequence_IR_ProvidesDescSeq::replace (CORBA::ULong max,
+  CORBA::ULong length,
+  IR::ProvidesDescription *data,
+  CORBA::Boolean release)
+  {
+    this->maximum_ = max;
+    this->length_ = length;
+    if (this->buffer_ && this->release_ == 1)
+    {
+      IR::ProvidesDescription *tmp = ACE_reinterpret_cast(IR::ProvidesDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_ProvidesDescSeq::freebuf (tmp);
+    }
+    this->buffer_ = data;
+    this->release_ = release;
+  }
+  
+#endif /* end #if !defined */
+
+
+#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
+
+#if !defined (_IR_PROVIDESDESCSEQ_CI_)
+#define _IR_PROVIDESDESCSEQ_CI_
+
 // *************************************************************
-// Inline operations for class CORBA_ValueMember_var
+// Inline operations for class IR::ProvidesDescSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueMember_var::CORBA_ValueMember_var (void) // default constructor
+IR::ProvidesDescSeq_var::ProvidesDescSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ValueMember_var::CORBA_ValueMember_var (CORBA_ValueMember *p)
+IR::ProvidesDescSeq_var::ProvidesDescSeq_var (ProvidesDescSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ValueMember_var::CORBA_ValueMember_var (const CORBA_ValueMember_var &p) // copy constructor
+IR::ProvidesDescSeq_var::ProvidesDescSeq_var (const ::IR::ProvidesDescSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ValueMember(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ProvidesDescSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueMember_var::~CORBA_ValueMember_var (void) // destructor
+IR::ProvidesDescSeq_var::~ProvidesDescSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMember_var &
-CORBA_ValueMember_var::operator= (CORBA_ValueMember *p)
+ACE_INLINE IR::ProvidesDescSeq_var &
+IR::ProvidesDescSeq_var::operator= (ProvidesDescSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueMember_var &
-CORBA_ValueMember_var::operator= (const CORBA_ValueMember_var &p)
+ACE_INLINE IR::ProvidesDescSeq_var &
+IR::ProvidesDescSeq_var::operator= (const ::IR::ProvidesDescSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ValueMember (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ProvidesDescSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ValueMember *
-CORBA_ValueMember_var::operator-> (void) const
+ACE_INLINE const ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMember *
-CORBA_ValueMember_var::operator-> (void)
+ACE_INLINE ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueMember_var::operator const CORBA_ValueMember &() const // cast
+IR::ProvidesDescSeq_var::operator const ::IR::ProvidesDescSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueMember_var::operator CORBA_ValueMember &() // cast 
+IR::ProvidesDescSeq_var::operator ::IR::ProvidesDescSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueMember_var::operator CORBA_ValueMember &() const// cast 
+IR::ProvidesDescSeq_var::operator ::IR::ProvidesDescSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_ValueMember &
-CORBA_ValueMember_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::ProvidesDescSeq_var::operator ::IR::ProvidesDescSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::ProvidesDescription &
+IR::ProvidesDescSeq_var::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+ACE_INLINE const ::IR::ProvidesDescSeq &
+IR::ProvidesDescSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMember &
-CORBA_ValueMember_var::inout (void)
+ACE_INLINE ::IR::ProvidesDescSeq &
+IR::ProvidesDescSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ValueMember *&
-CORBA_ValueMember_var::out (void)
+ACE_INLINE ::IR::ProvidesDescSeq *&
+IR::ProvidesDescSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMember *
-CORBA_ValueMember_var::_retn (void)
+ACE_INLINE ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_var::_retn (void)
 {
-  CORBA_ValueMember *tmp = this->ptr_;
+  ::IR::ProvidesDescSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ValueMember *
-CORBA_ValueMember_var::ptr (void) const
+ACE_INLINE ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ValueMember_out
+// Inline operations for class IR::ProvidesDescSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueMember_out::CORBA_ValueMember_out (CORBA_ValueMember *&p)
+IR::ProvidesDescSeq_out::ProvidesDescSeq_out (ProvidesDescSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueMember_out::CORBA_ValueMember_out (CORBA_ValueMember_var &p) // constructor from _var
+IR::ProvidesDescSeq_out::ProvidesDescSeq_out (ProvidesDescSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -11489,102 +17213,116 @@ CORBA_ValueMember_out::CORBA_ValueMember_out (CORBA_ValueMember_var &p) // const
 }
 
 ACE_INLINE
-CORBA_ValueMember_out::CORBA_ValueMember_out (const CORBA_ValueMember_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ValueMember_out&,p).ptr_)
+IR::ProvidesDescSeq_out::ProvidesDescSeq_out (const ::IR::ProvidesDescSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ProvidesDescSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ValueMember_out &
-CORBA_ValueMember_out::operator= (const CORBA_ValueMember_out &p)
+ACE_INLINE ::IR::ProvidesDescSeq_out &
+IR::ProvidesDescSeq_out::operator= (const ::IR::ProvidesDescSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ValueMember_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (ProvidesDescSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueMember_out &
-CORBA_ValueMember_out::operator= (CORBA_ValueMember *p)
+ACE_INLINE ::IR::ProvidesDescSeq_out &
+IR::ProvidesDescSeq_out::operator= (ProvidesDescSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueMember_out::operator CORBA_ValueMember *&() // cast
+IR::ProvidesDescSeq_out::operator ::IR::ProvidesDescSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMember *&
-CORBA_ValueMember_out::ptr (void) // ptr
+ACE_INLINE ::IR::ProvidesDescSeq *&
+IR::ProvidesDescSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMember *
-CORBA_ValueMember_out::operator-> (void)
+ACE_INLINE ::IR::ProvidesDescSeq *
+IR::ProvidesDescSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
+ACE_INLINE IR::ProvidesDescription &
+IR::ProvidesDescSeq_out::operator[] (CORBA::ULong index)
+{
+  return this->ptr_->operator[] (index);
+}
+
+
+#endif /* end #if !defined */
+
 
 #if !defined (TAO_USE_SEQUENCE_TEMPLATES)
   
-#if !defined (__TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CI_)
-#define __TAO_UNBOUNDED_SEQUENCE_CORBA_VALUEMEMBERSEQ_CI_
+#if !defined (__TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CI_)
+#define __TAO_UNBOUNDED_SEQUENCE_IR_USESDESCSEQ_CI_
 
   // = Static operations.
-  ACE_INLINE CORBA_ValueMember *
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (CORBA::ULong size)
+  ACE_INLINE IR::UsesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (CORBA::ULong size)
   // Allocate storage for the sequence.
   {
-    CORBA_ValueMember *retval = 0;
-    ACE_NEW_RETURN (retval,
-                    CORBA_ValueMember[size],
-		    0);
+    IR::UsesDescription *retval = 0;
+    ACE_NEW_RETURN (retval, IR::UsesDescription[size], 0);
     return retval;
   }
   
-  ACE_INLINE void _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (CORBA_ValueMember *buffer)
+  ACE_INLINE void IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (IR::UsesDescription *buffer)
   // Free the sequence.
   {
     delete [] buffer;
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (void) // Default constructor.
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (void) // Default constructor.
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
-    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (maximum))
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum) // Constructor using a maximum length value.
+    : TAO_Unbounded_Base_Sequence (maximum, _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (maximum))
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (CORBA::ULong maximum,
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (CORBA::ULong maximum,
     CORBA::ULong length,
-    CORBA_ValueMember *data,
+    IR::UsesDescription *data,
     CORBA::Boolean release)
   : TAO_Unbounded_Base_Sequence (maximum, length, data, release)
   {
   }
   
   ACE_INLINE
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::_TAO_Unbounded_Sequence_CORBA_ValueMemberSeq (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::_TAO_Unbounded_Sequence_IR_UsesDescSeq (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs)
   // Copy constructor.
     : TAO_Unbounded_Base_Sequence (rhs)
   {
-    CORBA_ValueMember *tmp1 = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (this->maximum_);
-    CORBA_ValueMember * const tmp2 = ACE_reinterpret_cast (CORBA_ValueMember * ACE_CAST_CONST, rhs.buffer_);
-    
-    for (CORBA::ULong i = 0; i < this->length_; ++i)
-      tmp1[i] = tmp2[i];
-    
-    this->buffer_ = tmp1;
+    if (rhs.buffer_ != 0)
+    {
+      IR::UsesDescription *tmp1 = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (this->maximum_);
+      IR::UsesDescription * const tmp2 = ACE_reinterpret_cast (IR::UsesDescription * ACE_CAST_CONST, rhs.buffer_);
+      
+      for (CORBA::ULong i = 0; i < this->length_; ++i)
+        tmp1[i] = tmp2[i];
+      
+      this->buffer_ = tmp1;
+    }
+    else
+    {
+      this->buffer_ = 0;
+    }
   }
   
-  ACE_INLINE _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator= (const _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq &rhs)
+  ACE_INLINE IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq &
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::operator= (const _TAO_Unbounded_Sequence_IR_UsesDescSeq &rhs)
   // Assignment operator.
   {
     if (this == &rhs)
@@ -11595,18 +17333,18 @@ CORBA_ValueMember_out::operator-> (void)
       if (this->maximum_ < rhs.maximum_)
       {
         // free the old buffer
-        CORBA_ValueMember *tmp = ACE_reinterpret_cast (CORBA_ValueMember *, this->buffer_);
-        _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (tmp);
-        this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (rhs.maximum_);
+        IR::UsesDescription *tmp = ACE_reinterpret_cast (IR::UsesDescription *, this->buffer_);
+        _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (tmp);
+        this->buffer_ = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (rhs.maximum_);
       }
     }
     else
-      this->buffer_ = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (rhs.maximum_);
+      this->buffer_ = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (rhs.maximum_);
     
     TAO_Unbounded_Base_Sequence::operator= (rhs);
     
-    CORBA_ValueMember *tmp1 = ACE_reinterpret_cast (CORBA_ValueMember *, this->buffer_);
-    CORBA_ValueMember * const tmp2 = ACE_reinterpret_cast (CORBA_ValueMember * ACE_CAST_CONST, rhs.buffer_);
+    IR::UsesDescription *tmp1 = ACE_reinterpret_cast (IR::UsesDescription *, this->buffer_);
+    IR::UsesDescription * const tmp2 = ACE_reinterpret_cast (IR::UsesDescription * ACE_CAST_CONST, rhs.buffer_);
     
     for (CORBA::ULong i = 0; i < this->length_; ++i)
       tmp1[i] = tmp2[i];
@@ -11615,41 +17353,41 @@ CORBA_ValueMember_out::operator-> (void)
   }
   
   // = Accessors.
-  ACE_INLINE CORBA_ValueMember &
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i)
+  ACE_INLINE IR::UsesDescription &
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::operator[] (CORBA::ULong i)
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_ValueMember* tmp = ACE_reinterpret_cast(CORBA_ValueMember*,this->buffer_);
+    IR::UsesDescription* tmp = ACE_reinterpret_cast(IR::UsesDescription*,this->buffer_);
     return tmp[i];
   }
   
-  ACE_INLINE const CORBA_ValueMember &
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::operator[] (CORBA::ULong i) const
+  ACE_INLINE const IR::UsesDescription &
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::operator[] (CORBA::ULong i) const
   // operator []
   {
     ACE_ASSERT (i < this->maximum_);
-    CORBA_ValueMember * const tmp = ACE_reinterpret_cast (CORBA_ValueMember* ACE_CAST_CONST, this->buffer_);
+    IR::UsesDescription * const tmp = ACE_reinterpret_cast (IR::UsesDescription* ACE_CAST_CONST, this->buffer_);
     return tmp[i];
   }
   
   // Implement the TAO_Base_Sequence methods (see Sequence.h)
   
-  ACE_INLINE CORBA_ValueMember *
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (CORBA::Boolean orphan)
+  ACE_INLINE IR::UsesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::get_buffer (CORBA::Boolean orphan)
   {
-    CORBA_ValueMember *result = 0;
+    IR::UsesDescription *result = 0;
     if (orphan == 0)
     {
       // We retain ownership.
       if (this->buffer_ == 0)
       {
-        result = _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::allocbuf (this->length_);
+        result = _TAO_Unbounded_Sequence_IR_UsesDescSeq::allocbuf (this->length_);
         this->buffer_ = result;
       }
       else
       {
-        result = ACE_reinterpret_cast (CORBA_ValueMember*, this->buffer_);
+        result = ACE_reinterpret_cast (IR::UsesDescription*, this->buffer_);
       }
     }
     else // if (orphan == 1)
@@ -11658,7 +17396,7 @@ CORBA_ValueMember_out::operator-> (void)
       {
         // We set the state back to default and relinquish
         // ownership.
-        result = ACE_reinterpret_cast(CORBA_ValueMember*,this->buffer_);
+        result = ACE_reinterpret_cast(IR::UsesDescription*,this->buffer_);
         this->maximum_ = 0;
         this->length_ = 0;
         this->buffer_ = 0;
@@ -11668,24 +17406,24 @@ CORBA_ValueMember_out::operator-> (void)
     return result;
   }
   
-  ACE_INLINE const CORBA_ValueMember *
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::get_buffer (void) const
+  ACE_INLINE const IR::UsesDescription *
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::get_buffer (void) const
   {
-    return ACE_reinterpret_cast(const CORBA_ValueMember * ACE_CAST_CONST, this->buffer_);
+    return ACE_reinterpret_cast(const IR::UsesDescription * ACE_CAST_CONST, this->buffer_);
   }
   
   ACE_INLINE void
-  _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::replace (CORBA::ULong max,
+  IR::_TAO_Unbounded_Sequence_IR_UsesDescSeq::replace (CORBA::ULong max,
   CORBA::ULong length,
-  CORBA_ValueMember *data,
+  IR::UsesDescription *data,
   CORBA::Boolean release)
   {
     this->maximum_ = max;
     this->length_ = length;
     if (this->buffer_ && this->release_ == 1)
     {
-      CORBA_ValueMember *tmp = ACE_reinterpret_cast(CORBA_ValueMember*,this->buffer_);
-      _TAO_Unbounded_Sequence_CORBA_ValueMemberSeq::freebuf (tmp);
+      IR::UsesDescription *tmp = ACE_reinterpret_cast(IR::UsesDescription*,this->buffer_);
+      _TAO_Unbounded_Sequence_IR_UsesDescSeq::freebuf (tmp);
     }
     this->buffer_ = data;
     this->release_ = release;
@@ -11696,144 +17434,148 @@ CORBA_ValueMember_out::operator-> (void)
 
 #endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 
-#if !defined (_CORBA_VALUEMEMBERSEQ_CI_)
-#define _CORBA_VALUEMEMBERSEQ_CI_
+#if !defined (_IR_USESDESCSEQ_CI_)
+#define _IR_USESDESCSEQ_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ValueMemberSeq_var
+// Inline operations for class IR::UsesDescSeq_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueMemberSeq_var::CORBA_ValueMemberSeq_var (void) // default constructor
+IR::UsesDescSeq_var::UsesDescSeq_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ValueMemberSeq_var::CORBA_ValueMemberSeq_var (CORBA_ValueMemberSeq *p)
+IR::UsesDescSeq_var::UsesDescSeq_var (UsesDescSeq *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ValueMemberSeq_var::CORBA_ValueMemberSeq_var (const CORBA_ValueMemberSeq_var &p) // copy constructor
+IR::UsesDescSeq_var::UsesDescSeq_var (const ::IR::UsesDescSeq_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ValueMemberSeq(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::UsesDescSeq (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueMemberSeq_var::~CORBA_ValueMemberSeq_var (void) // destructor
+IR::UsesDescSeq_var::~UsesDescSeq_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberSeq_var &
-CORBA_ValueMemberSeq_var::operator= (CORBA_ValueMemberSeq *p)
+ACE_INLINE IR::UsesDescSeq_var &
+IR::UsesDescSeq_var::operator= (UsesDescSeq *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueMemberSeq_var &
-CORBA_ValueMemberSeq_var::operator= (const CORBA_ValueMemberSeq_var &p) // deep copy
+ACE_INLINE IR::UsesDescSeq_var &
+IR::UsesDescSeq_var::operator= (const ::IR::UsesDescSeq_var &p) // deep copy
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ValueMemberSeq (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::UsesDescSeq (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ValueMemberSeq *
-CORBA_ValueMemberSeq_var::operator-> (void) const
+ACE_INLINE const ::IR::UsesDescSeq *
+IR::UsesDescSeq_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberSeq *
-CORBA_ValueMemberSeq_var::operator-> (void)
+ACE_INLINE ::IR::UsesDescSeq *
+IR::UsesDescSeq_var::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueMemberSeq_var::operator const CORBA_ValueMemberSeq &() const // cast
+IR::UsesDescSeq_var::operator const ::IR::UsesDescSeq &() const // cast
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueMemberSeq_var::operator CORBA_ValueMemberSeq &() // cast 
+IR::UsesDescSeq_var::operator ::IR::UsesDescSeq &() // cast 
 {
   return *this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueMemberSeq_var::operator CORBA_ValueMemberSeq &() const// cast 
+IR::UsesDescSeq_var::operator ::IR::UsesDescSeq &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMember &
-CORBA_ValueMemberSeq_var::operator[] (CORBA::ULong index)
+// variable-size types only
+ACE_INLINE
+IR::UsesDescSeq_var::operator ::IR::UsesDescSeq *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE IR::UsesDescription &
+IR::UsesDescSeq_var::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
 
-ACE_INLINE const CORBA_ValueMemberSeq &
-CORBA_ValueMemberSeq_var::in (void) const
+ACE_INLINE const ::IR::UsesDescSeq &
+IR::UsesDescSeq_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberSeq &
-CORBA_ValueMemberSeq_var::inout (void)
+ACE_INLINE ::IR::UsesDescSeq &
+IR::UsesDescSeq_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ValueMemberSeq *&
-CORBA_ValueMemberSeq_var::out (void)
+ACE_INLINE ::IR::UsesDescSeq *&
+IR::UsesDescSeq_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberSeq *
-CORBA_ValueMemberSeq_var::_retn (void)
+ACE_INLINE ::IR::UsesDescSeq *
+IR::UsesDescSeq_var::_retn (void)
 {
-  CORBA_ValueMemberSeq *tmp = this->ptr_;
+  ::IR::UsesDescSeq *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ValueMemberSeq *
-CORBA_ValueMemberSeq_var::ptr (void) const
+ACE_INLINE ::IR::UsesDescSeq *
+IR::UsesDescSeq_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ValueMemberSeq_out
+// Inline operations for class IR::UsesDescSeq_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueMemberSeq_out::CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq *&p)
+IR::UsesDescSeq_out::UsesDescSeq_out (UsesDescSeq *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueMemberSeq_out::CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq_var &p) // constructor from _var
+IR::UsesDescSeq_out::UsesDescSeq_out (UsesDescSeq_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -11841,44 +17583,44 @@ CORBA_ValueMemberSeq_out::CORBA_ValueMemberSeq_out (CORBA_ValueMemberSeq_var &p)
 }
 
 ACE_INLINE
-CORBA_ValueMemberSeq_out::CORBA_ValueMemberSeq_out (const CORBA_ValueMemberSeq_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ValueMemberSeq_out&,p).ptr_)
+IR::UsesDescSeq_out::UsesDescSeq_out (const ::IR::UsesDescSeq_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (UsesDescSeq_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ValueMemberSeq_out &
-CORBA_ValueMemberSeq_out::operator= (const CORBA_ValueMemberSeq_out &p)
+ACE_INLINE ::IR::UsesDescSeq_out &
+IR::UsesDescSeq_out::operator= (const ::IR::UsesDescSeq_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ValueMemberSeq_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (UsesDescSeq_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueMemberSeq_out &
-CORBA_ValueMemberSeq_out::operator= (CORBA_ValueMemberSeq *p)
+ACE_INLINE ::IR::UsesDescSeq_out &
+IR::UsesDescSeq_out::operator= (UsesDescSeq *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueMemberSeq_out::operator CORBA_ValueMemberSeq *&() // cast
+IR::UsesDescSeq_out::operator ::IR::UsesDescSeq *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberSeq *&
-CORBA_ValueMemberSeq_out::ptr (void) // ptr
+ACE_INLINE ::IR::UsesDescSeq *&
+IR::UsesDescSeq_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberSeq *
-CORBA_ValueMemberSeq_out::operator-> (void)
+ACE_INLINE ::IR::UsesDescSeq *
+IR::UsesDescSeq_out::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMember &
-CORBA_ValueMemberSeq_out::operator[] (CORBA::ULong index)
+ACE_INLINE IR::UsesDescription &
+IR::UsesDescSeq_out::operator[] (CORBA::ULong index)
 {
   return this->ptr_->operator[] (index);
 }
@@ -11887,116 +17629,479 @@ CORBA_ValueMemberSeq_out::operator[] (CORBA::ULong index)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_ValueMemberDef::CORBA_ValueMemberDef (void) // default constructor
+IR::EventDef::EventDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::EventDef::EventDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::EventDef::~EventDef (void) // destructor
+{}
+
+
+#if !defined (_IR_EVENTDEF___VAR_CI_)
+#define _IR_EVENTDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::EventDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::EventDef_var::EventDef_var (void) // default constructor
+  : ptr_ (EventDef::_nil ())
+{}
+
+ACE_INLINE
+IR::EventDef_var::EventDef_var (EventDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::EventDef_ptr
+IR::EventDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::EventDef_var::EventDef_var (const ::IR::EventDef_var &p) // copy constructor
+  : ptr_ (EventDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::EventDef_var::~EventDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::EventDef_var &
+IR::EventDef_var::operator= (EventDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::EventDef_var &
+IR::EventDef_var::operator= (const ::IR::EventDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::EventDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::EventDef_var::operator const ::IR::EventDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::EventDef_var::operator ::IR::EventDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDef_ptr
+IR::EventDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDef_ptr
+IR::EventDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDef_ptr &
+IR::EventDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDef_ptr &
+IR::EventDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::EventDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDef_ptr
+IR::EventDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::EventDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::EventDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_EVENTDEF___OUT_CI_)
+#define _IR_EVENTDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::EventDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::EventDef_out::EventDef_out (EventDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::EventDef::_nil ();
+}
+
+ACE_INLINE
+IR::EventDef_out::EventDef_out (EventDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::EventDef::_nil ();
+}
+
+ACE_INLINE
+IR::EventDef_out::EventDef_out (const ::IR::EventDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (EventDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::EventDef_out &
+IR::EventDef_out::operator= (const ::IR::EventDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (EventDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::EventDef_out &
+IR::EventDef_out::operator= (const ::IR::EventDef_var &p)
+{
+  this->ptr_ = ::IR::EventDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::EventDef_out &
+IR::EventDef_out::operator= (EventDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::EventDef_out::operator ::IR::EventDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDef_ptr &
+IR::EventDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDef_ptr
+IR::EventDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class IR::EventDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::EventDescription_var::EventDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::EventDescription_var::EventDescription_var (EventDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::EventDescription_var::EventDescription_var (const ::IR::EventDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::EventDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EventDescription_var::~EventDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::EventDescription_var &
+IR::EventDescription_var::operator= (EventDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::EventDescription_var &
+IR::EventDescription_var::operator= (const ::IR::EventDescription_var &p)
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::EventDescription (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::EventDescription *
+IR::EventDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription *
+IR::EventDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::EventDescription_var::operator const ::IR::EventDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::EventDescription_var::operator ::IR::EventDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::EventDescription_var::operator ::IR::EventDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::EventDescription_var::operator ::IR::EventDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::EventDescription &
+IR::EventDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription &
+IR::EventDescription_var::inout (void)
+{
+  return *this->ptr_;
+}
+
+// mapping for variable size 
+ACE_INLINE ::IR::EventDescription *&
+IR::EventDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription *
+IR::EventDescription_var::_retn (void)
+{
+  ::IR::EventDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::EventDescription *
+IR::EventDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::EventDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::EventDescription_out::EventDescription_out (::IR::EventDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EventDescription_out::EventDescription_out (EventDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::EventDescription_out::EventDescription_out (const ::IR::EventDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (EventDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::EventDescription_out &
+IR::EventDescription_out::operator= (const ::IR::EventDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (EventDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::EventDescription_out &
+IR::EventDescription_out::operator= (EventDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::EventDescription_out::operator ::IR::EventDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription *&
+IR::EventDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::EventDescription *
+IR::EventDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::EmitsDef::EmitsDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_ValueMemberDef::CORBA_ValueMemberDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::EmitsDef::EmitsDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_ValueMemberDef::~CORBA_ValueMemberDef (void) // destructor
+IR::EmitsDef::~EmitsDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_VALUEMEMBERDEF___VAR_CI_)
-#define _CORBA_VALUEMEMBERDEF___VAR_CI_
+#if !defined (_IR_EMITSDEF___VAR_CI_)
+#define _IR_EMITSDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ValueMemberDef_var
+// Inline operations for class IR::EmitsDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueMemberDef_var::CORBA_ValueMemberDef_var (void) // default constructor
-  : ptr_ (CORBA_ValueMemberDef::_nil ())
+IR::EmitsDef_var::EmitsDef_var (void) // default constructor
+  : ptr_ (EmitsDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_ValueMemberDef_var::CORBA_ValueMemberDef_var (CORBA_ValueMemberDef_ptr p)
+IR::EmitsDef_var::EmitsDef_var (EmitsDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_ValueMemberDef_ptr 
-CORBA_ValueMemberDef_var::ptr (void) const
+ACE_INLINE ::IR::EmitsDef_ptr
+IR::EmitsDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ValueMemberDef_var::CORBA_ValueMemberDef_var (const CORBA_ValueMemberDef_var &p) // copy constructor
-  : ptr_ (CORBA_ValueMemberDef::_duplicate (p.ptr ()))
+IR::EmitsDef_var::EmitsDef_var (const ::IR::EmitsDef_var &p) // copy constructor
+  : ptr_ (EmitsDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_ValueMemberDef_var::~CORBA_ValueMemberDef_var (void) // destructor
+IR::EmitsDef_var::~EmitsDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_ValueMemberDef_var &
-CORBA_ValueMemberDef_var::operator= (CORBA_ValueMemberDef_ptr p)
+ACE_INLINE IR::EmitsDef_var &
+IR::EmitsDef_var::operator= (EmitsDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_var &
-CORBA_ValueMemberDef_var::operator= (const CORBA_ValueMemberDef_var &p)
+ACE_INLINE IR::EmitsDef_var &
+IR::EmitsDef_var::operator= (const ::IR::EmitsDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_ValueMemberDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::EmitsDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueMemberDef_var::operator const CORBA_ValueMemberDef_ptr &() const // cast
+IR::EmitsDef_var::operator const ::IR::EmitsDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueMemberDef_var::operator CORBA_ValueMemberDef_ptr &() // cast 
+IR::EmitsDef_var::operator ::IR::EmitsDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_ptr 
-CORBA_ValueMemberDef_var::operator-> (void) const
+ACE_INLINE ::IR::EmitsDef_ptr
+IR::EmitsDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_ptr
-CORBA_ValueMemberDef_var::in (void) const
+ACE_INLINE ::IR::EmitsDef_ptr
+IR::EmitsDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_ptr &
-CORBA_ValueMemberDef_var::inout (void)
+ACE_INLINE ::IR::EmitsDef_ptr &
+IR::EmitsDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_ptr &
-CORBA_ValueMemberDef_var::out (void)
+ACE_INLINE ::IR::EmitsDef_ptr &
+IR::EmitsDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ValueMemberDef::_nil ();
+  this->ptr_ = ::IR::EmitsDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_ptr 
-CORBA_ValueMemberDef_var::_retn (void)
+ACE_INLINE ::IR::EmitsDef_ptr
+IR::EmitsDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_ValueMemberDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_ValueMemberDef::_nil ();
+  ::IR::EmitsDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::EmitsDef::_nil ();
   return val;
 }
 
@@ -12004,68 +18109,68 @@ CORBA_ValueMemberDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEMEMBERDEF___OUT_CI_)
-#define _CORBA_VALUEMEMBERDEF___OUT_CI_
+#if !defined (_IR_EMITSDEF___OUT_CI_)
+#define _IR_EMITSDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ValueMemberDef_out
+// Inline operations for class IR::EmitsDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueMemberDef_out::CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_ptr &p)
+IR::EmitsDef_out::EmitsDef_out (EmitsDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_ValueMemberDef::_nil ();
+  this->ptr_ = ::IR::EmitsDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_ValueMemberDef_out::CORBA_ValueMemberDef_out (CORBA_ValueMemberDef_var &p) // constructor from _var
+IR::EmitsDef_out::EmitsDef_out (EmitsDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ValueMemberDef::_nil ();
+  this->ptr_ = ::IR::EmitsDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_ValueMemberDef_out::CORBA_ValueMemberDef_out (const CORBA_ValueMemberDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ValueMemberDef_out&,p).ptr_)
+IR::EmitsDef_out::EmitsDef_out (const ::IR::EmitsDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (EmitsDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ValueMemberDef_out &
-CORBA_ValueMemberDef_out::operator= (const CORBA_ValueMemberDef_out &p)
+ACE_INLINE ::IR::EmitsDef_out &
+IR::EmitsDef_out::operator= (const ::IR::EmitsDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ValueMemberDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (EmitsDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_out &
-CORBA_ValueMemberDef_out::operator= (const CORBA_ValueMemberDef_var &p)
+ACE_INLINE IR::EmitsDef_out &
+IR::EmitsDef_out::operator= (const ::IR::EmitsDef_var &p)
 {
-  this->ptr_ = CORBA_ValueMemberDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::EmitsDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_out &
-CORBA_ValueMemberDef_out::operator= (CORBA_ValueMemberDef_ptr p)
+ACE_INLINE IR::EmitsDef_out &
+IR::EmitsDef_out::operator= (EmitsDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueMemberDef_out::operator CORBA_ValueMemberDef_ptr &() // cast
+IR::EmitsDef_out::operator ::IR::EmitsDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_ptr &
-CORBA_ValueMemberDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::EmitsDef_ptr &
+IR::EmitsDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueMemberDef_ptr 
-CORBA_ValueMemberDef_out::operator-> (void)
+ACE_INLINE ::IR::EmitsDef_ptr
+IR::EmitsDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -12074,116 +18179,116 @@ CORBA_ValueMemberDef_out::operator-> (void)
 #endif /* end #if !defined */
 
 ACE_INLINE
-CORBA_ValueDef::CORBA_ValueDef (void) // default constructor
+IR::PublishesDef::PublishesDef (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_ValueDef::CORBA_ValueDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+IR::PublishesDef::PublishesDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_ValueDef::~CORBA_ValueDef (void) // destructor
+IR::PublishesDef::~PublishesDef (void) // destructor
 {}
 
 
-#if !defined (_CORBA_VALUEDEF___VAR_CI_)
-#define _CORBA_VALUEDEF___VAR_CI_
+#if !defined (_IR_PUBLISHESDEF___VAR_CI_)
+#define _IR_PUBLISHESDEF___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ValueDef_var
+// Inline operations for class IR::PublishesDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueDef_var::CORBA_ValueDef_var (void) // default constructor
-  : ptr_ (CORBA_ValueDef::_nil ())
+IR::PublishesDef_var::PublishesDef_var (void) // default constructor
+  : ptr_ (PublishesDef::_nil ())
 {}
 
 ACE_INLINE
-CORBA_ValueDef_var::CORBA_ValueDef_var (CORBA_ValueDef_ptr p)
+IR::PublishesDef_var::PublishesDef_var (PublishesDef_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_ValueDef_ptr 
-CORBA_ValueDef_var::ptr (void) const
+ACE_INLINE ::IR::PublishesDef_ptr
+IR::PublishesDef_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ValueDef_var::CORBA_ValueDef_var (const CORBA_ValueDef_var &p) // copy constructor
-  : ptr_ (CORBA_ValueDef::_duplicate (p.ptr ()))
+IR::PublishesDef_var::PublishesDef_var (const ::IR::PublishesDef_var &p) // copy constructor
+  : ptr_ (PublishesDef::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_ValueDef_var::~CORBA_ValueDef_var (void) // destructor
+IR::PublishesDef_var::~PublishesDef_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_ValueDef_var &
-CORBA_ValueDef_var::operator= (CORBA_ValueDef_ptr p)
+ACE_INLINE IR::PublishesDef_var &
+IR::PublishesDef_var::operator= (PublishesDef_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueDef_var &
-CORBA_ValueDef_var::operator= (const CORBA_ValueDef_var &p)
+ACE_INLINE IR::PublishesDef_var &
+IR::PublishesDef_var::operator= (const ::IR::PublishesDef_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_ValueDef::_duplicate (p.ptr ());
+    this->ptr_ = ::IR::PublishesDef::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueDef_var::operator const CORBA_ValueDef_ptr &() const // cast
+IR::PublishesDef_var::operator const ::IR::PublishesDef_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueDef_var::operator CORBA_ValueDef_ptr &() // cast 
+IR::PublishesDef_var::operator ::IR::PublishesDef_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef_ptr 
-CORBA_ValueDef_var::operator-> (void) const
+ACE_INLINE ::IR::PublishesDef_ptr
+IR::PublishesDef_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef_ptr
-CORBA_ValueDef_var::in (void) const
+ACE_INLINE ::IR::PublishesDef_ptr
+IR::PublishesDef_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef_ptr &
-CORBA_ValueDef_var::inout (void)
+ACE_INLINE ::IR::PublishesDef_ptr &
+IR::PublishesDef_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef_ptr &
-CORBA_ValueDef_var::out (void)
+ACE_INLINE ::IR::PublishesDef_ptr &
+IR::PublishesDef_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ValueDef::_nil ();
+  this->ptr_ = ::IR::PublishesDef::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef_ptr 
-CORBA_ValueDef_var::_retn (void)
+ACE_INLINE ::IR::PublishesDef_ptr
+IR::PublishesDef_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_ValueDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_ValueDef::_nil ();
+  ::IR::PublishesDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::PublishesDef::_nil ();
   return val;
 }
 
@@ -12191,68 +18296,68 @@ CORBA_ValueDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEDEF___OUT_CI_)
-#define _CORBA_VALUEDEF___OUT_CI_
+#if !defined (_IR_PUBLISHESDEF___OUT_CI_)
+#define _IR_PUBLISHESDEF___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ValueDef_out
+// Inline operations for class IR::PublishesDef_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueDef_out::CORBA_ValueDef_out (CORBA_ValueDef_ptr &p)
+IR::PublishesDef_out::PublishesDef_out (PublishesDef_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_ValueDef::_nil ();
+  this->ptr_ = ::IR::PublishesDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_ValueDef_out::CORBA_ValueDef_out (CORBA_ValueDef_var &p) // constructor from _var
+IR::PublishesDef_out::PublishesDef_out (PublishesDef_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ValueDef::_nil ();
+  this->ptr_ = ::IR::PublishesDef::_nil ();
 }
 
 ACE_INLINE
-CORBA_ValueDef_out::CORBA_ValueDef_out (const CORBA_ValueDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ValueDef_out&,p).ptr_)
+IR::PublishesDef_out::PublishesDef_out (const ::IR::PublishesDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (PublishesDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ValueDef_out &
-CORBA_ValueDef_out::operator= (const CORBA_ValueDef_out &p)
+ACE_INLINE ::IR::PublishesDef_out &
+IR::PublishesDef_out::operator= (const ::IR::PublishesDef_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ValueDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (PublishesDef_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueDef_out &
-CORBA_ValueDef_out::operator= (const CORBA_ValueDef_var &p)
+ACE_INLINE IR::PublishesDef_out &
+IR::PublishesDef_out::operator= (const ::IR::PublishesDef_var &p)
 {
-  this->ptr_ = CORBA_ValueDef::_duplicate (p.ptr ());
+  this->ptr_ = ::IR::PublishesDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_ValueDef_out &
-CORBA_ValueDef_out::operator= (CORBA_ValueDef_ptr p)
+ACE_INLINE IR::PublishesDef_out &
+IR::PublishesDef_out::operator= (PublishesDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueDef_out::operator CORBA_ValueDef_ptr &() // cast
+IR::PublishesDef_out::operator ::IR::PublishesDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef_ptr &
-CORBA_ValueDef_out::ptr (void) // ptr
+ACE_INLINE ::IR::PublishesDef_ptr &
+IR::PublishesDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef_ptr 
-CORBA_ValueDef_out::operator-> (void)
+ACE_INLINE ::IR::PublishesDef_ptr
+IR::PublishesDef_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -12260,135 +18365,513 @@ CORBA_ValueDef_out::operator-> (void)
 
 #endif /* end #if !defined */
 
+ACE_INLINE
+IR::ConsumesDef::ConsumesDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::ConsumesDef::ConsumesDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::ConsumesDef::~ConsumesDef (void) // destructor
+{}
+
+
+#if !defined (_IR_CONSUMESDEF___VAR_CI_)
+#define _IR_CONSUMESDEF___VAR_CI_
+
 // *************************************************************
-// Inline operations for class CORBA_ValueDef::FullValueDescription_var
+// Inline operations for class IR::ConsumesDef_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueDef::FullValueDescription_var::FullValueDescription_var (void) // default constructor
+IR::ConsumesDef_var::ConsumesDef_var (void) // default constructor
+  : ptr_ (ConsumesDef::_nil ())
+{}
+
+ACE_INLINE
+IR::ConsumesDef_var::ConsumesDef_var (ConsumesDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::ConsumesDef_ptr
+IR::ConsumesDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ConsumesDef_var::ConsumesDef_var (const ::IR::ConsumesDef_var &p) // copy constructor
+  : ptr_ (ConsumesDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ConsumesDef_var::~ConsumesDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ConsumesDef_var &
+IR::ConsumesDef_var::operator= (ConsumesDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ConsumesDef_var &
+IR::ConsumesDef_var::operator= (const ::IR::ConsumesDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::ConsumesDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::ConsumesDef_var::operator const ::IR::ConsumesDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ConsumesDef_var::operator ::IR::ConsumesDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDef_ptr
+IR::ConsumesDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDef_ptr
+IR::ConsumesDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDef_ptr &
+IR::ConsumesDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDef_ptr &
+IR::ConsumesDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ConsumesDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDef_ptr
+IR::ConsumesDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::ConsumesDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ConsumesDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_CONSUMESDEF___OUT_CI_)
+#define _IR_CONSUMESDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ConsumesDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::ConsumesDef_out::ConsumesDef_out (ConsumesDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::ConsumesDef::_nil ();
+}
+
+ACE_INLINE
+IR::ConsumesDef_out::ConsumesDef_out (ConsumesDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ConsumesDef::_nil ();
+}
+
+ACE_INLINE
+IR::ConsumesDef_out::ConsumesDef_out (const ::IR::ConsumesDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ConsumesDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ConsumesDef_out &
+IR::ConsumesDef_out::operator= (const ::IR::ConsumesDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (ConsumesDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ConsumesDef_out &
+IR::ConsumesDef_out::operator= (const ::IR::ConsumesDef_var &p)
+{
+  this->ptr_ = ::IR::ConsumesDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ConsumesDef_out &
+IR::ConsumesDef_out::operator= (ConsumesDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ConsumesDef_out::operator ::IR::ConsumesDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDef_ptr &
+IR::ConsumesDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ConsumesDef_ptr
+IR::ConsumesDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+ACE_INLINE
+IR::ComponentDef::ComponentDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::ComponentDef::ComponentDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::ComponentDef::~ComponentDef (void) // destructor
+{}
+
+
+#if !defined (_IR_COMPONENTDEF___VAR_CI_)
+#define _IR_COMPONENTDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::ComponentDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentDef_var::ComponentDef_var (void) // default constructor
+  : ptr_ (ComponentDef::_nil ())
+{}
+
+ACE_INLINE
+IR::ComponentDef_var::ComponentDef_var (ComponentDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::ComponentDef_ptr
+IR::ComponentDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::ComponentDef_var::ComponentDef_var (const ::IR::ComponentDef_var &p) // copy constructor
+  : ptr_ (ComponentDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::ComponentDef_var::~ComponentDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::ComponentDef_var &
+IR::ComponentDef_var::operator= (ComponentDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::ComponentDef_var &
+IR::ComponentDef_var::operator= (const ::IR::ComponentDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::ComponentDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::ComponentDef_var::operator const ::IR::ComponentDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::ComponentDef_var::operator ::IR::ComponentDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDef_ptr
+IR::ComponentDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDef_ptr
+IR::ComponentDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDef_ptr &
+IR::ComponentDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDef_ptr &
+IR::ComponentDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ComponentDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDef_ptr
+IR::ComponentDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::ComponentDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::ComponentDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_COMPONENTDEF___OUT_CI_)
+#define _IR_COMPONENTDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::ComponentDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentDef_out::ComponentDef_out (ComponentDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::ComponentDef::_nil ();
+}
+
+ACE_INLINE
+IR::ComponentDef_out::ComponentDef_out (ComponentDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::ComponentDef::_nil ();
+}
+
+ACE_INLINE
+IR::ComponentDef_out::ComponentDef_out (const ::IR::ComponentDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ComponentDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::ComponentDef_out &
+IR::ComponentDef_out::operator= (const ::IR::ComponentDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (ComponentDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ComponentDef_out &
+IR::ComponentDef_out::operator= (const ::IR::ComponentDef_var &p)
+{
+  this->ptr_ = ::IR::ComponentDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::ComponentDef_out &
+IR::ComponentDef_out::operator= (ComponentDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ComponentDef_out::operator ::IR::ComponentDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDef_ptr &
+IR::ComponentDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDef_ptr
+IR::ComponentDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class IR::ComponentDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::ComponentDescription_var::ComponentDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ValueDef::FullValueDescription_var::FullValueDescription_var (CORBA_ValueDef::FullValueDescription *p)
+IR::ComponentDescription_var::ComponentDescription_var (ComponentDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ValueDef::FullValueDescription_var::FullValueDescription_var (const CORBA_ValueDef::FullValueDescription_var &p) // copy constructor
+IR::ComponentDescription_var::ComponentDescription_var (const ::IR::ComponentDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ValueDef::FullValueDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::ComponentDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueDef::FullValueDescription_var::~FullValueDescription_var (void) // destructor
+IR::ComponentDescription_var::~ComponentDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription_var &
-CORBA_ValueDef::FullValueDescription_var::operator= (CORBA_ValueDef::FullValueDescription *p)
+ACE_INLINE IR::ComponentDescription_var &
+IR::ComponentDescription_var::operator= (ComponentDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription_var &
-CORBA_ValueDef::FullValueDescription_var::operator= (const CORBA_ValueDef::FullValueDescription_var &p)
+ACE_INLINE ::IR::ComponentDescription_var &
+IR::ComponentDescription_var::operator= (const ::IR::ComponentDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ValueDef::FullValueDescription (*p.ptr_), 
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::ComponentDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ValueDef::FullValueDescription *
-CORBA_ValueDef::FullValueDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::ComponentDescription *
+IR::ComponentDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription *
-CORBA_ValueDef::FullValueDescription_var::operator-> (void)
+ACE_INLINE ::IR::ComponentDescription *
+IR::ComponentDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ValueDef::FullValueDescription_var::operator const CORBA_ValueDef::FullValueDescription &() const // cast
+ACE_INLINE
+IR::ComponentDescription_var::operator const ::IR::ComponentDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ValueDef::FullValueDescription_var::operator CORBA_ValueDef::FullValueDescription &() // cast 
+ACE_INLINE
+IR::ComponentDescription_var::operator ::IR::ComponentDescription &() // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ValueDef::FullValueDescription_var::operator CORBA_ValueDef::FullValueDescription &() const// cast 
+ACE_INLINE
+IR::ComponentDescription_var::operator ::IR::ComponentDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_ValueDef::FullValueDescription &
-CORBA_ValueDef::FullValueDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::ComponentDescription_var::operator ::IR::ComponentDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::ComponentDescription &
+IR::ComponentDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription &
-CORBA_ValueDef::FullValueDescription_var::inout (void)
+ACE_INLINE ::IR::ComponentDescription &
+IR::ComponentDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ValueDef::FullValueDescription *&
-CORBA_ValueDef::FullValueDescription_var::out (void)
+ACE_INLINE ::IR::ComponentDescription *&
+IR::ComponentDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription *
-CORBA_ValueDef::FullValueDescription_var::_retn (void)
+ACE_INLINE ::IR::ComponentDescription *
+IR::ComponentDescription_var::_retn (void)
 {
-  CORBA_ValueDef::FullValueDescription *tmp = this->ptr_;
+  ::IR::ComponentDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription *
-CORBA_ValueDef::FullValueDescription_var::ptr (void) const
+ACE_INLINE ::IR::ComponentDescription *
+IR::ComponentDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ValueDef::FullValueDescription_out
+// Inline operations for class IR::ComponentDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueDef::FullValueDescription_out::FullValueDescription_out (CORBA_ValueDef::FullValueDescription *&p)
+IR::ComponentDescription_out::ComponentDescription_out (::IR::ComponentDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueDef::FullValueDescription_out::FullValueDescription_out (CORBA_ValueDef::FullValueDescription_var &p) // constructor from _var
+IR::ComponentDescription_out::ComponentDescription_out (ComponentDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -12396,171 +18879,1099 @@ CORBA_ValueDef::FullValueDescription_out::FullValueDescription_out (CORBA_ValueD
 }
 
 ACE_INLINE
-CORBA_ValueDef::FullValueDescription_out::FullValueDescription_out (const CORBA_ValueDef::FullValueDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ValueDef::FullValueDescription_out&,p).ptr_)
+IR::ComponentDescription_out::ComponentDescription_out (const ::IR::ComponentDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (ComponentDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::ComponentDescription_out &
+IR::ComponentDescription_out::operator= (const ::IR::ComponentDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (ComponentDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::ComponentDescription_out &
+IR::ComponentDescription_out::operator= (ComponentDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::ComponentDescription_out::operator ::IR::ComponentDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDescription *&
+IR::ComponentDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::ComponentDescription *
+IR::ComponentDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDef::PrimaryKeyDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::PrimaryKeyDef::PrimaryKeyDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::PrimaryKeyDef::~PrimaryKeyDef (void) // destructor
+{}
+
+
+#if !defined (_IR_PRIMARYKEYDEF___VAR_CI_)
+#define _IR_PRIMARYKEYDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::PrimaryKeyDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::PrimaryKeyDef_var::PrimaryKeyDef_var (void) // default constructor
+  : ptr_ (PrimaryKeyDef::_nil ())
+{}
+
+ACE_INLINE
+IR::PrimaryKeyDef_var::PrimaryKeyDef_var (PrimaryKeyDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::PrimaryKeyDef_ptr
+IR::PrimaryKeyDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDef_var::PrimaryKeyDef_var (const ::IR::PrimaryKeyDef_var &p) // copy constructor
+  : ptr_ (PrimaryKeyDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::PrimaryKeyDef_var::~PrimaryKeyDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::PrimaryKeyDef_var &
+IR::PrimaryKeyDef_var::operator= (PrimaryKeyDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_var &
+IR::PrimaryKeyDef_var::operator= (const ::IR::PrimaryKeyDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::PrimaryKeyDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::PrimaryKeyDef_var::operator const ::IR::PrimaryKeyDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::PrimaryKeyDef_var::operator ::IR::PrimaryKeyDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDef_ptr
+IR::PrimaryKeyDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDef_ptr
+IR::PrimaryKeyDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDef_ptr &
+IR::PrimaryKeyDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDef_ptr &
+IR::PrimaryKeyDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::PrimaryKeyDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDef_ptr
+IR::PrimaryKeyDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::PrimaryKeyDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::PrimaryKeyDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_PRIMARYKEYDEF___OUT_CI_)
+#define _IR_PRIMARYKEYDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::PrimaryKeyDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::PrimaryKeyDef_out::PrimaryKeyDef_out (PrimaryKeyDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::PrimaryKeyDef::_nil ();
+}
+
+ACE_INLINE
+IR::PrimaryKeyDef_out::PrimaryKeyDef_out (PrimaryKeyDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::PrimaryKeyDef::_nil ();
+}
+
+ACE_INLINE
+IR::PrimaryKeyDef_out::PrimaryKeyDef_out (const ::IR::PrimaryKeyDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (PrimaryKeyDef_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription_out &
-CORBA_ValueDef::FullValueDescription_out::operator= (const CORBA_ValueDef::FullValueDescription_out &p)
+ACE_INLINE ::IR::PrimaryKeyDef_out &
+IR::PrimaryKeyDef_out::operator= (const ::IR::PrimaryKeyDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (PrimaryKeyDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::PrimaryKeyDef_out &
+IR::PrimaryKeyDef_out::operator= (const ::IR::PrimaryKeyDef_var &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ValueDef::FullValueDescription_out&,p).ptr_;
+  this->ptr_ = ::IR::PrimaryKeyDef::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription_out &
-CORBA_ValueDef::FullValueDescription_out::operator= (CORBA_ValueDef::FullValueDescription *p)
+ACE_INLINE IR::PrimaryKeyDef_out &
+IR::PrimaryKeyDef_out::operator= (PrimaryKeyDef_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueDef::FullValueDescription_out::operator CORBA_ValueDef::FullValueDescription *&() // cast
+IR::PrimaryKeyDef_out::operator ::IR::PrimaryKeyDef_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription *&
-CORBA_ValueDef::FullValueDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::PrimaryKeyDef_ptr &
+IR::PrimaryKeyDef_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDef::FullValueDescription *
-CORBA_ValueDef::FullValueDescription_out::operator-> (void)
+ACE_INLINE ::IR::PrimaryKeyDef_ptr
+IR::PrimaryKeyDef_out::operator-> (void)
 {
   return this->ptr_;
 }
 
+
+#endif /* end #if !defined */
+
 // *************************************************************
-// Inline operations for class CORBA_ValueDescription_var
+// Inline operations for class IR::PrimaryKeyDescription_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueDescription_var::CORBA_ValueDescription_var (void) // default constructor
+IR::PrimaryKeyDescription_var::PrimaryKeyDescription_var (void) // default constructor
   : ptr_ (0)
 {}
 
 ACE_INLINE
-CORBA_ValueDescription_var::CORBA_ValueDescription_var (CORBA_ValueDescription *p)
+IR::PrimaryKeyDescription_var::PrimaryKeyDescription_var (PrimaryKeyDescription *p)
   : ptr_ (p)
 {}
 
 ACE_INLINE
-CORBA_ValueDescription_var::CORBA_ValueDescription_var (const CORBA_ValueDescription_var &p) // copy constructor
+IR::PrimaryKeyDescription_var::PrimaryKeyDescription_var (const ::IR::PrimaryKeyDescription_var &p) // copy constructor
 {
   if (p.ptr_)
-    ACE_NEW (this->ptr_, 
-             CORBA_ValueDescription(*p.ptr_));
+    ACE_NEW (this->ptr_, ::IR::PrimaryKeyDescription (*p.ptr_));
   else
     this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueDescription_var::~CORBA_ValueDescription_var (void) // destructor
+IR::PrimaryKeyDescription_var::~PrimaryKeyDescription_var (void) // destructor
 {
   delete this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDescription_var &
-CORBA_ValueDescription_var::operator= (CORBA_ValueDescription *p)
+ACE_INLINE IR::PrimaryKeyDescription_var &
+IR::PrimaryKeyDescription_var::operator= (PrimaryKeyDescription *p)
 {
   delete this->ptr_;
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueDescription_var &
-CORBA_ValueDescription_var::operator= (const CORBA_ValueDescription_var &p)
+ACE_INLINE ::IR::PrimaryKeyDescription_var &
+IR::PrimaryKeyDescription_var::operator= (const ::IR::PrimaryKeyDescription_var &p)
 {
   if (this != &p)
   {
     delete this->ptr_;
-    ACE_NEW_RETURN (this->ptr_, 
-                    CORBA_ValueDescription (*p.ptr_),
-		    *this);
+    ACE_NEW_RETURN (this->ptr_, ::IR::PrimaryKeyDescription (*p.ptr_), *this);
   }
   return *this;
 }
 
-ACE_INLINE const CORBA_ValueDescription *
-CORBA_ValueDescription_var::operator-> (void) const
+ACE_INLINE const ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDescription *
-CORBA_ValueDescription_var::operator-> (void)
+ACE_INLINE ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_var::operator-> (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ValueDescription_var::operator const CORBA_ValueDescription &() const // cast
+ACE_INLINE
+IR::PrimaryKeyDescription_var::operator const ::IR::PrimaryKeyDescription &() const // cast
 {
   return *this->ptr_;
 }
 
-ACE_INLINE 
-CORBA_ValueDescription_var::operator CORBA_ValueDescription &() // cast 
+ACE_INLINE
+IR::PrimaryKeyDescription_var::operator ::IR::PrimaryKeyDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_var::operator ::IR::PrimaryKeyDescription &() const // cast 
+{
+  return *this->ptr_;
+}
+
+// variable-size types only
+ACE_INLINE
+IR::PrimaryKeyDescription_var::operator ::IR::PrimaryKeyDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::PrimaryKeyDescription &
+IR::PrimaryKeyDescription_var::in (void) const
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription &
+IR::PrimaryKeyDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
+// mapping for variable size 
+ACE_INLINE ::IR::PrimaryKeyDescription *&
+IR::PrimaryKeyDescription_var::out (void)
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_var::_retn (void)
+{
+  ::IR::PrimaryKeyDescription *tmp = this->ptr_;
+  this->ptr_ = 0;
+  return tmp;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+// *************************************************************
+// Inline operations for class IR::PrimaryKeyDescription_out
+// *************************************************************
+
+ACE_INLINE
+IR::PrimaryKeyDescription_out::PrimaryKeyDescription_out (::IR::PrimaryKeyDescription *&p)
+  : ptr_ (p)
+{
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_out::PrimaryKeyDescription_out (PrimaryKeyDescription_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  delete this->ptr_;
+  this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::PrimaryKeyDescription_out::PrimaryKeyDescription_out (const ::IR::PrimaryKeyDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (PrimaryKeyDescription_out&, p).ptr_)
+{}
+
+ACE_INLINE IR::PrimaryKeyDescription_out &
+IR::PrimaryKeyDescription_out::operator= (const ::IR::PrimaryKeyDescription_out &p)
+{
+  this->ptr_ = ACE_const_cast (PrimaryKeyDescription_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::PrimaryKeyDescription_out &
+IR::PrimaryKeyDescription_out::operator= (PrimaryKeyDescription *p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::PrimaryKeyDescription_out::operator ::IR::PrimaryKeyDescription *&() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription *&
+IR::PrimaryKeyDescription_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::PrimaryKeyDescription *
+IR::PrimaryKeyDescription_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::FactoryDef::FactoryDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::FactoryDef::FactoryDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::FactoryDef::~FactoryDef (void) // destructor
+{}
+
+
+#if !defined (_IR_FACTORYDEF___VAR_CI_)
+#define _IR_FACTORYDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::FactoryDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::FactoryDef_var::FactoryDef_var (void) // default constructor
+  : ptr_ (FactoryDef::_nil ())
+{}
+
+ACE_INLINE
+IR::FactoryDef_var::FactoryDef_var (FactoryDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::FactoryDef_ptr
+IR::FactoryDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::FactoryDef_var::FactoryDef_var (const ::IR::FactoryDef_var &p) // copy constructor
+  : ptr_ (FactoryDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::FactoryDef_var::~FactoryDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::FactoryDef_var &
+IR::FactoryDef_var::operator= (FactoryDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::FactoryDef_var &
+IR::FactoryDef_var::operator= (const ::IR::FactoryDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::FactoryDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::FactoryDef_var::operator const ::IR::FactoryDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::FactoryDef_var::operator ::IR::FactoryDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDef_ptr
+IR::FactoryDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDef_ptr
+IR::FactoryDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDef_ptr &
+IR::FactoryDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDef_ptr &
+IR::FactoryDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::FactoryDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDef_ptr
+IR::FactoryDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::FactoryDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::FactoryDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FACTORYDEF___OUT_CI_)
+#define _IR_FACTORYDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::FactoryDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::FactoryDef_out::FactoryDef_out (FactoryDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::FactoryDef::_nil ();
+}
+
+ACE_INLINE
+IR::FactoryDef_out::FactoryDef_out (FactoryDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::FactoryDef::_nil ();
+}
+
+ACE_INLINE
+IR::FactoryDef_out::FactoryDef_out (const ::IR::FactoryDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (FactoryDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::FactoryDef_out &
+IR::FactoryDef_out::operator= (const ::IR::FactoryDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (FactoryDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::FactoryDef_out &
+IR::FactoryDef_out::operator= (const ::IR::FactoryDef_var &p)
+{
+  this->ptr_ = ::IR::FactoryDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::FactoryDef_out &
+IR::FactoryDef_out::operator= (FactoryDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::FactoryDef_out::operator ::IR::FactoryDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDef_ptr &
+IR::FactoryDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FactoryDef_ptr
+IR::FactoryDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+ACE_INLINE
+IR::FinderDef::FinderDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::FinderDef::FinderDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::FinderDef::~FinderDef (void) // destructor
+{}
+
+
+#if !defined (_IR_FINDERDEF___VAR_CI_)
+#define _IR_FINDERDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::FinderDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::FinderDef_var::FinderDef_var (void) // default constructor
+  : ptr_ (FinderDef::_nil ())
+{}
+
+ACE_INLINE
+IR::FinderDef_var::FinderDef_var (FinderDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::FinderDef_ptr
+IR::FinderDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::FinderDef_var::FinderDef_var (const ::IR::FinderDef_var &p) // copy constructor
+  : ptr_ (FinderDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::FinderDef_var::~FinderDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::FinderDef_var &
+IR::FinderDef_var::operator= (FinderDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::FinderDef_var &
+IR::FinderDef_var::operator= (const ::IR::FinderDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::FinderDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::FinderDef_var::operator const ::IR::FinderDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::FinderDef_var::operator ::IR::FinderDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDef_ptr
+IR::FinderDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDef_ptr
+IR::FinderDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDef_ptr &
+IR::FinderDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDef_ptr &
+IR::FinderDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::FinderDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDef_ptr
+IR::FinderDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::FinderDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::FinderDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_FINDERDEF___OUT_CI_)
+#define _IR_FINDERDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::FinderDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::FinderDef_out::FinderDef_out (FinderDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::FinderDef::_nil ();
+}
+
+ACE_INLINE
+IR::FinderDef_out::FinderDef_out (FinderDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::FinderDef::_nil ();
+}
+
+ACE_INLINE
+IR::FinderDef_out::FinderDef_out (const ::IR::FinderDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (FinderDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::FinderDef_out &
+IR::FinderDef_out::operator= (const ::IR::FinderDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (FinderDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::FinderDef_out &
+IR::FinderDef_out::operator= (const ::IR::FinderDef_var &p)
+{
+  this->ptr_ = ::IR::FinderDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::FinderDef_out &
+IR::FinderDef_out::operator= (FinderDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE 
+IR::FinderDef_out::operator ::IR::FinderDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDef_ptr &
+IR::FinderDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::FinderDef_ptr
+IR::FinderDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+ACE_INLINE
+IR::HomeDef::HomeDef (void) // default constructor
+{}
+
+ACE_INLINE
+IR::HomeDef::HomeDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+  : CORBA_Object (objref, _tao_servant, _tao_collocated)
+{}
+
+ACE_INLINE
+IR::HomeDef::~HomeDef (void) // destructor
+{}
+
+
+#if !defined (_IR_HOMEDEF___VAR_CI_)
+#define _IR_HOMEDEF___VAR_CI_
+
+// *************************************************************
+// Inline operations for class IR::HomeDef_var
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDef_var::HomeDef_var (void) // default constructor
+  : ptr_ (HomeDef::_nil ())
+{}
+
+ACE_INLINE
+IR::HomeDef_var::HomeDef_var (HomeDef_ptr p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE ::IR::HomeDef_ptr
+IR::HomeDef_var::ptr (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::HomeDef_var::HomeDef_var (const ::IR::HomeDef_var &p) // copy constructor
+  : ptr_ (HomeDef::_duplicate (p.ptr ()))
+{}
+
+ACE_INLINE
+IR::HomeDef_var::~HomeDef_var (void) // destructor
+{
+  CORBA::release (this->ptr_);
+}
+
+ACE_INLINE IR::HomeDef_var &
+IR::HomeDef_var::operator= (HomeDef_ptr p)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE IR::HomeDef_var &
+IR::HomeDef_var::operator= (const ::IR::HomeDef_var &p)
+{
+  if (this != &p)
+  {
+    CORBA::release (this->ptr_);
+    this->ptr_ = ::IR::HomeDef::_duplicate (p.ptr ());
+  }
+  return *this;
+}
+
+ACE_INLINE 
+IR::HomeDef_var::operator const ::IR::HomeDef_ptr &() const // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE 
+IR::HomeDef_var::operator ::IR::HomeDef_ptr &() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDef_ptr
+IR::HomeDef_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDef_ptr
+IR::HomeDef_var::in (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDef_ptr &
+IR::HomeDef_var::inout (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDef_ptr &
+IR::HomeDef_var::out (void)
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::HomeDef::_nil ();
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDef_ptr
+IR::HomeDef_var::_retn (void)
+{
+  // yield ownership of managed obj reference
+  ::IR::HomeDef_ptr val = this->ptr_;
+  this->ptr_ = ::IR::HomeDef::_nil ();
+  return val;
+}
+
+
+#endif /* end #if !defined */
+
+
+#if !defined (_IR_HOMEDEF___OUT_CI_)
+#define _IR_HOMEDEF___OUT_CI_
+
+// *************************************************************
+// Inline operations for class IR::HomeDef_out
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDef_out::HomeDef_out (HomeDef_ptr &p)
+  : ptr_ (p)
+{
+  this->ptr_ = ::IR::HomeDef::_nil ();
+}
+
+ACE_INLINE
+IR::HomeDef_out::HomeDef_out (HomeDef_var &p) // constructor from _var
+  : ptr_ (p.out ())
+{
+  CORBA::release (this->ptr_);
+  this->ptr_ = ::IR::HomeDef::_nil ();
+}
+
+ACE_INLINE
+IR::HomeDef_out::HomeDef_out (const ::IR::HomeDef_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (HomeDef_out &, p).ptr_)
+{}
+
+ACE_INLINE ::IR::HomeDef_out &
+IR::HomeDef_out::operator= (const ::IR::HomeDef_out &p)
+{
+  this->ptr_ = ACE_const_cast (HomeDef_out&, p).ptr_;
+  return *this;
+}
+
+ACE_INLINE IR::HomeDef_out &
+IR::HomeDef_out::operator= (const ::IR::HomeDef_var &p)
+{
+  this->ptr_ = ::IR::HomeDef::_duplicate (p.ptr ());
+  return *this;
+}
+
+ACE_INLINE IR::HomeDef_out &
+IR::HomeDef_out::operator= (HomeDef_ptr p)
+{
+  this->ptr_ = p;
+  return *this;
+}
+
 ACE_INLINE 
-CORBA_ValueDescription_var::operator CORBA_ValueDescription &() const// cast 
+IR::HomeDef_out::operator ::IR::HomeDef_ptr &() // cast
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDef_ptr &
+IR::HomeDef_out::ptr (void) // ptr
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDef_ptr
+IR::HomeDef_out::operator-> (void)
+{
+  return this->ptr_;
+}
+
+
+#endif /* end #if !defined */
+
+// *************************************************************
+// Inline operations for class IR::HomeDescription_var
+// *************************************************************
+
+ACE_INLINE
+IR::HomeDescription_var::HomeDescription_var (void) // default constructor
+  : ptr_ (0)
+{}
+
+ACE_INLINE
+IR::HomeDescription_var::HomeDescription_var (HomeDescription *p)
+  : ptr_ (p)
+{}
+
+ACE_INLINE
+IR::HomeDescription_var::HomeDescription_var (const ::IR::HomeDescription_var &p) // copy constructor
+{
+  if (p.ptr_)
+    ACE_NEW (this->ptr_, ::IR::HomeDescription (*p.ptr_));
+  else
+    this->ptr_ = 0;
+}
+
+ACE_INLINE
+IR::HomeDescription_var::~HomeDescription_var (void) // destructor
+{
+  delete this->ptr_;
+}
+
+ACE_INLINE IR::HomeDescription_var &
+IR::HomeDescription_var::operator= (HomeDescription *p)
+{
+  delete this->ptr_;
+  this->ptr_ = p;
+  return *this;
+}
+
+ACE_INLINE ::IR::HomeDescription_var &
+IR::HomeDescription_var::operator= (const ::IR::HomeDescription_var &p)
+{
+  if (this != &p)
+  {
+    delete this->ptr_;
+    ACE_NEW_RETURN (this->ptr_, ::IR::HomeDescription (*p.ptr_), *this);
+  }
+  return *this;
+}
+
+ACE_INLINE const ::IR::HomeDescription *
+IR::HomeDescription_var::operator-> (void) const
+{
+  return this->ptr_;
+}
+
+ACE_INLINE ::IR::HomeDescription *
+IR::HomeDescription_var::operator-> (void)
+{
+  return this->ptr_;
+}
+
+ACE_INLINE
+IR::HomeDescription_var::operator const ::IR::HomeDescription &() const // cast
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::HomeDescription_var::operator ::IR::HomeDescription &() // cast 
+{
+  return *this->ptr_;
+}
+
+ACE_INLINE
+IR::HomeDescription_var::operator ::IR::HomeDescription &() const // cast 
 {
   return *this->ptr_;
 }
 
-ACE_INLINE const CORBA_ValueDescription &
-CORBA_ValueDescription_var::in (void) const
+// variable-size types only
+ACE_INLINE
+IR::HomeDescription_var::operator ::IR::HomeDescription *&() // cast 
+{
+  return this->ptr_;
+}
+
+ACE_INLINE const ::IR::HomeDescription &
+IR::HomeDescription_var::in (void) const
 {
   return *this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDescription &
-CORBA_ValueDescription_var::inout (void)
+ACE_INLINE ::IR::HomeDescription &
+IR::HomeDescription_var::inout (void)
 {
   return *this->ptr_;
 }
 
 // mapping for variable size 
-ACE_INLINE CORBA_ValueDescription *&
-CORBA_ValueDescription_var::out (void)
+ACE_INLINE ::IR::HomeDescription *&
+IR::HomeDescription_var::out (void)
 {
   delete this->ptr_;
   this->ptr_ = 0;
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDescription *
-CORBA_ValueDescription_var::_retn (void)
+ACE_INLINE ::IR::HomeDescription *
+IR::HomeDescription_var::_retn (void)
 {
-  CORBA_ValueDescription *tmp = this->ptr_;
+  ::IR::HomeDescription *tmp = this->ptr_;
   this->ptr_ = 0;
   return tmp;
 }
 
-ACE_INLINE CORBA_ValueDescription *
-CORBA_ValueDescription_var::ptr (void) const
+ACE_INLINE ::IR::HomeDescription *
+IR::HomeDescription_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 // *************************************************************
-// Inline operations for class CORBA_ValueDescription_out
+// Inline operations for class IR::HomeDescription_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueDescription_out::CORBA_ValueDescription_out (CORBA_ValueDescription *&p)
+IR::HomeDescription_out::HomeDescription_out (::IR::HomeDescription *&p)
   : ptr_ (p)
 {
   this->ptr_ = 0;
 }
 
 ACE_INLINE
-CORBA_ValueDescription_out::CORBA_ValueDescription_out (CORBA_ValueDescription_var &p) // constructor from _var
+IR::HomeDescription_out::HomeDescription_out (HomeDescription_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   delete this->ptr_;
@@ -12568,153 +19979,153 @@ CORBA_ValueDescription_out::CORBA_ValueDescription_out (CORBA_ValueDescription_v
 }
 
 ACE_INLINE
-CORBA_ValueDescription_out::CORBA_ValueDescription_out (const CORBA_ValueDescription_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ValueDescription_out&,p).ptr_)
+IR::HomeDescription_out::HomeDescription_out (const ::IR::HomeDescription_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (HomeDescription_out&, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ValueDescription_out &
-CORBA_ValueDescription_out::operator= (const CORBA_ValueDescription_out &p)
+ACE_INLINE IR::HomeDescription_out &
+IR::HomeDescription_out::operator= (const ::IR::HomeDescription_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ValueDescription_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (HomeDescription_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueDescription_out &
-CORBA_ValueDescription_out::operator= (CORBA_ValueDescription *p)
+ACE_INLINE IR::HomeDescription_out &
+IR::HomeDescription_out::operator= (HomeDescription *p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueDescription_out::operator CORBA_ValueDescription *&() // cast
+IR::HomeDescription_out::operator ::IR::HomeDescription *&() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDescription *&
-CORBA_ValueDescription_out::ptr (void) // ptr
+ACE_INLINE ::IR::HomeDescription *&
+IR::HomeDescription_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueDescription *
-CORBA_ValueDescription_out::operator-> (void)
+ACE_INLINE ::IR::HomeDescription *
+IR::HomeDescription_out::operator-> (void)
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ValueBoxDef::CORBA_ValueBoxDef (void) // default constructor
+CORBA_TypeCodeFactory::TypeCodeFactory (void) // default constructor
 {}
 
 ACE_INLINE
-CORBA_ValueBoxDef::CORBA_ValueBoxDef (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
+CORBA_TypeCodeFactory::TypeCodeFactory (TAO_Stub *objref, TAO_ServantBase *_tao_servant, CORBA::Boolean _tao_collocated) // constructor
   : CORBA_Object (objref, _tao_servant, _tao_collocated)
 {}
 
 ACE_INLINE
-CORBA_ValueBoxDef::~CORBA_ValueBoxDef (void) // destructor
+CORBA_TypeCodeFactory::~TypeCodeFactory (void) // destructor
 {}
 
 
-#if !defined (_CORBA_VALUEBOXDEF___VAR_CI_)
-#define _CORBA_VALUEBOXDEF___VAR_CI_
+#if !defined (_CORBA_TYPECODEFACTORY___VAR_CI_)
+#define _CORBA_TYPECODEFACTORY___VAR_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ValueBoxDef_var
+// Inline operations for class CORBA_TypeCodeFactory_var
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueBoxDef_var::CORBA_ValueBoxDef_var (void) // default constructor
-  : ptr_ (CORBA_ValueBoxDef::_nil ())
+CORBA_TypeCodeFactory_var::CORBA_TypeCodeFactory_var (void) // default constructor
+  : ptr_ (TypeCodeFactory::_nil ())
 {}
 
 ACE_INLINE
-CORBA_ValueBoxDef_var::CORBA_ValueBoxDef_var (CORBA_ValueBoxDef_ptr p)
+CORBA_TypeCodeFactory_var::CORBA_TypeCodeFactory_var (CORBA_TypeCodeFactory_ptr p)
   : ptr_ (p)
 {}
 
-ACE_INLINE CORBA_ValueBoxDef_ptr 
-CORBA_ValueBoxDef_var::ptr (void) const
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_var::ptr (void) const
 {
   return this->ptr_;
 }
 
 ACE_INLINE
-CORBA_ValueBoxDef_var::CORBA_ValueBoxDef_var (const CORBA_ValueBoxDef_var &p) // copy constructor
-  : ptr_ (CORBA_ValueBoxDef::_duplicate (p.ptr ()))
+CORBA_TypeCodeFactory_var::CORBA_TypeCodeFactory_var (const ::CORBA_TypeCodeFactory_var &p) // copy constructor
+  : ptr_ (CORBA_TypeCodeFactory::_duplicate (p.ptr ()))
 {}
 
 ACE_INLINE
-CORBA_ValueBoxDef_var::~CORBA_ValueBoxDef_var (void) // destructor
+CORBA_TypeCodeFactory_var::~CORBA_TypeCodeFactory_var (void) // destructor
 {
   CORBA::release (this->ptr_);
 }
 
-ACE_INLINE CORBA_ValueBoxDef_var &
-CORBA_ValueBoxDef_var::operator= (CORBA_ValueBoxDef_ptr p)
+ACE_INLINE CORBA_TypeCodeFactory_var &
+CORBA_TypeCodeFactory_var::operator= (CORBA_TypeCodeFactory_ptr p)
 {
   CORBA::release (this->ptr_);
   this->ptr_ = p;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_var &
-CORBA_ValueBoxDef_var::operator= (const CORBA_ValueBoxDef_var &p)
+ACE_INLINE CORBA_TypeCodeFactory_var &
+CORBA_TypeCodeFactory_var::operator= (const ::CORBA_TypeCodeFactory_var &p)
 {
   if (this != &p)
   {
     CORBA::release (this->ptr_);
-    this->ptr_ = CORBA_ValueBoxDef::_duplicate (p.ptr ());
+    this->ptr_ = ::CORBA_TypeCodeFactory::_duplicate (p.ptr ());
   }
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueBoxDef_var::operator const CORBA_ValueBoxDef_ptr &() const // cast
+CORBA_TypeCodeFactory_var::operator const ::CORBA_TypeCodeFactory_ptr &() const // cast
 {
   return this->ptr_;
 }
 
 ACE_INLINE 
-CORBA_ValueBoxDef_var::operator CORBA_ValueBoxDef_ptr &() // cast 
+CORBA_TypeCodeFactory_var::operator ::CORBA_TypeCodeFactory_ptr &() // cast 
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_ptr 
-CORBA_ValueBoxDef_var::operator-> (void) const
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_var::operator-> (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_ptr
-CORBA_ValueBoxDef_var::in (void) const
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_var::in (void) const
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_ptr &
-CORBA_ValueBoxDef_var::inout (void)
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr &
+CORBA_TypeCodeFactory_var::inout (void)
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_ptr &
-CORBA_ValueBoxDef_var::out (void)
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr &
+CORBA_TypeCodeFactory_var::out (void)
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ValueBoxDef::_nil ();
+  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_ptr 
-CORBA_ValueBoxDef_var::_retn (void)
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_var::_retn (void)
 {
   // yield ownership of managed obj reference
-  CORBA_ValueBoxDef_ptr val = this->ptr_;
-  this->ptr_ = CORBA_ValueBoxDef::_nil ();
+  ::CORBA_TypeCodeFactory_ptr val = this->ptr_;
+  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
   return val;
 }
 
@@ -12722,68 +20133,68 @@ CORBA_ValueBoxDef_var::_retn (void)
 #endif /* end #if !defined */
 
 
-#if !defined (_CORBA_VALUEBOXDEF___OUT_CI_)
-#define _CORBA_VALUEBOXDEF___OUT_CI_
+#if !defined (_CORBA_TYPECODEFACTORY___OUT_CI_)
+#define _CORBA_TYPECODEFACTORY___OUT_CI_
 
 // *************************************************************
-// Inline operations for class CORBA_ValueBoxDef_out
+// Inline operations for class CORBA_TypeCodeFactory_out
 // *************************************************************
 
 ACE_INLINE
-CORBA_ValueBoxDef_out::CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_ptr &p)
+CORBA_TypeCodeFactory_out::CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_ptr &p)
   : ptr_ (p)
 {
-  this->ptr_ = CORBA_ValueBoxDef::_nil ();
+  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
 }
 
 ACE_INLINE
-CORBA_ValueBoxDef_out::CORBA_ValueBoxDef_out (CORBA_ValueBoxDef_var &p) // constructor from _var
+CORBA_TypeCodeFactory_out::CORBA_TypeCodeFactory_out (CORBA_TypeCodeFactory_var &p) // constructor from _var
   : ptr_ (p.out ())
 {
   CORBA::release (this->ptr_);
-  this->ptr_ = CORBA_ValueBoxDef::_nil ();
+  this->ptr_ = ::CORBA_TypeCodeFactory::_nil ();
 }
 
 ACE_INLINE
-CORBA_ValueBoxDef_out::CORBA_ValueBoxDef_out (const CORBA_ValueBoxDef_out &p) // copy constructor
-  : ptr_ (ACE_const_cast (CORBA_ValueBoxDef_out&,p).ptr_)
+CORBA_TypeCodeFactory_out::CORBA_TypeCodeFactory_out (const ::CORBA_TypeCodeFactory_out &p) // copy constructor
+  : ptr_ (ACE_const_cast (CORBA_TypeCodeFactory_out &, p).ptr_)
 {}
 
-ACE_INLINE CORBA_ValueBoxDef_out &
-CORBA_ValueBoxDef_out::operator= (const CORBA_ValueBoxDef_out &p)
+ACE_INLINE ::CORBA_TypeCodeFactory_out &
+CORBA_TypeCodeFactory_out::operator= (const ::CORBA_TypeCodeFactory_out &p)
 {
-  this->ptr_ = ACE_const_cast (CORBA_ValueBoxDef_out&,p).ptr_;
+  this->ptr_ = ACE_const_cast (CORBA_TypeCodeFactory_out&, p).ptr_;
   return *this;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_out &
-CORBA_ValueBoxDef_out::operator= (const CORBA_ValueBoxDef_var &p)
+ACE_INLINE CORBA_TypeCodeFactory_out &
+CORBA_TypeCodeFactory_out::operator= (const ::CORBA_TypeCodeFactory_var &p)
 {
-  this->ptr_ = CORBA_ValueBoxDef::_duplicate (p.ptr ());
+  this->ptr_ = ::CORBA_TypeCodeFactory::_duplicate (p.ptr ());
   return *this;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_out &
-CORBA_ValueBoxDef_out::operator= (CORBA_ValueBoxDef_ptr p)
+ACE_INLINE CORBA_TypeCodeFactory_out &
+CORBA_TypeCodeFactory_out::operator= (CORBA_TypeCodeFactory_ptr p)
 {
   this->ptr_ = p;
   return *this;
 }
 
 ACE_INLINE 
-CORBA_ValueBoxDef_out::operator CORBA_ValueBoxDef_ptr &() // cast
+CORBA_TypeCodeFactory_out::operator ::CORBA_TypeCodeFactory_ptr &() // cast
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_ptr &
-CORBA_ValueBoxDef_out::ptr (void) // ptr
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr &
+CORBA_TypeCodeFactory_out::ptr (void) // ptr
 {
   return this->ptr_;
 }
 
-ACE_INLINE CORBA_ValueBoxDef_ptr 
-CORBA_ValueBoxDef_out::operator-> (void)
+ACE_INLINE ::CORBA_TypeCodeFactory_ptr
+CORBA_TypeCodeFactory_out::operator-> (void)
 {
   return this->ptr_;
 }
@@ -12791,12 +20202,12 @@ CORBA_ValueBoxDef_out::operator-> (void)
 
 #endif /* end #if !defined */
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::DefinitionKind &_tao_enumval)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::DefinitionKind &_tao_enumval)
 {
   return strm.write_ulong ((CORBA::ULong) _tao_enumval);
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::DefinitionKind &_tao_enumval)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::DefinitionKind &_tao_enumval)
 {
   CORBA::ULong _tao_temp;
   if (strm.read_ulong (_tao_temp))
@@ -12810,17 +20221,6 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::DefinitionKind
 
 ACE_INLINE CORBA::Boolean
 operator<< (
-    TAO_OutputCDR &,
-    const CORBA_IRObject_ptr
-  );
-ACE_INLINE CORBA::Boolean
-operator>> (
-    TAO_InputCDR &,
-    CORBA_IRObject_ptr &
-  );
-
-ACE_INLINE CORBA::Boolean
-operator<< (
     TAO_OutputCDR &strm,
     const CORBA_IRObject_ptr _tao_objref
   )
@@ -12860,45 +20260,45 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_Contained_ptr
+    const IR::Contained_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_Contained_ptr &
+    IR::Contained_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_Repository_ptr
+    const IR::Repository_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_Repository_ptr &
+    IR::Repository_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_Container_ptr
+    const IR::Container_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_Container_ptr &
+    IR::Container_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_Contained_ptr
+    const IR::Contained_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_Contained_ptr &
+    IR::Contained_ptr &
   );
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Contained::Description &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::Contained::Description &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.kind) &&
@@ -12910,7 +20310,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Contained
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_Contained::Description &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::Contained::Description &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.kind) &&
@@ -12925,27 +20325,27 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_Contained::Descr
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_Contained_ptr _tao_objref
+    const IR::Contained_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_Contained_ptr &_tao_objref
+    IR::Contained_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_Contained::_narrow (
+      IR::Contained::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -12963,151 +20363,414 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ModuleDef_ptr
+    const IR::ModuleDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ModuleDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ConstantDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ConstantDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::IDLType_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::IDLType_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::StructDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ModuleDef_ptr &
+    IR::StructDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ConstantDef_ptr
+    const IR::UnionDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ConstantDef_ptr &
+    IR::UnionDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_IDLType_ptr
+    const IR::EnumDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_IDLType_ptr &
+    IR::EnumDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_StructDef_ptr
+    const IR::AliasDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_StructDef_ptr &
+    IR::AliasDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_UnionDef_ptr
+    const IR::InterfaceDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_UnionDef_ptr &
+    IR::InterfaceDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_EnumDef_ptr
+    const IR::ExceptionDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_EnumDef_ptr &
+    IR::ExceptionDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::NativeDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::NativeDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_InterfaceDefSeq_I_
+#define _TAO_CDR_OP_IR_InterfaceDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::InterfaceDefSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::InterfaceDefSeq &
   );
+
+#endif /* _TAO_CDR_OP_IR_InterfaceDefSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_AliasDef_ptr
+    const IR::ValueDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_AliasDef_ptr &
+    IR::ValueDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_ValueDefSeq_I_
+#define _TAO_CDR_OP_IR_ValueDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ValueDefSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::ValueDefSeq &
   );
+
+#endif /* _TAO_CDR_OP_IR_ValueDefSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_InterfaceDef_ptr
+    const IR::ValueBoxDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_InterfaceDef_ptr &
+    IR::ValueBoxDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ExceptionDef_ptr
+    const IR::ComponentDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ExceptionDef_ptr &
+    IR::ComponentDef_ptr &
   );
+
+#if !defined _TAO_CDR_OP_IR_ComponentDefSeq_I_
+#define _TAO_CDR_OP_IR_ComponentDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ComponentDefSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::ComponentDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ComponentDefSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_NativeDef_ptr
+    const IR::ProvidesDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_NativeDef_ptr &
+    IR::ProvidesDef_ptr &
   );
-CORBA::Boolean  operator<< (
+
+#if !defined _TAO_CDR_OP_IR_ProvidesDefSeq_I_
+#define _TAO_CDR_OP_IR_ProvidesDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_InterfaceDefSeq &
+    const IR::ProvidesDefSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_InterfaceDefSeq &
+    IR::ProvidesDefSeq &
   );
 
+#endif /* _TAO_CDR_OP_IR_ProvidesDefSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ValueDef_ptr
+    const IR::UsesDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ValueDef_ptr &
+    IR::UsesDef_ptr &
   );
-CORBA::Boolean  operator<< (
+
+#if !defined _TAO_CDR_OP_IR_UsesDefSeq_I_
+#define _TAO_CDR_OP_IR_UsesDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_ValueDefSeq &
+    const IR::UsesDefSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_ValueDefSeq &
+    IR::UsesDefSeq &
   );
 
+#endif /* _TAO_CDR_OP_IR_UsesDefSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ValueBoxDef_ptr
+    const IR::HomeDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ValueBoxDef_ptr &
+    IR::HomeDef_ptr &
   );
-CORBA::Boolean  operator<< (
+
+#if !defined _TAO_CDR_OP_IR_HomeDefSeq_I_
+#define _TAO_CDR_OP_IR_HomeDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_ContainedSeq &
+    const IR::HomeDefSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_ContainedSeq &
+    IR::HomeDefSeq &
   );
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_StructMember &_tao_aggregate)
+#endif /* _TAO_CDR_OP_IR_HomeDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::EventDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::EventDef_ptr &
+  );
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::EmitsDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::EmitsDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_EmitsDefSeq_I_
+#define _TAO_CDR_OP_IR_EmitsDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::EmitsDefSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::EmitsDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_EmitsDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::PublishesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::PublishesDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_PublishesDefSeq_I_
+#define _TAO_CDR_OP_IR_PublishesDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::PublishesDefSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::PublishesDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_PublishesDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ConsumesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ConsumesDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_ConsumesDefSeq_I_
+#define _TAO_CDR_OP_IR_ConsumesDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ConsumesDefSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::ConsumesDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ConsumesDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::FactoryDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::FactoryDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_FactoryDefSeq_I_
+#define _TAO_CDR_OP_IR_FactoryDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::FactoryDefSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::FactoryDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_FactoryDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::FinderDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::FinderDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_FinderDefSeq_I_
+#define _TAO_CDR_OP_IR_FinderDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::FinderDefSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::FinderDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_FinderDefSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::PrimaryKeyDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::PrimaryKeyDef_ptr &
+  );
+
+#if !defined _TAO_CDR_OP_IR_ContainedSeq_I_
+#define _TAO_CDR_OP_IR_ContainedSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ContainedSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::ContainedSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ContainedSeq_I_ */
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::StructMember &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -13120,7 +20783,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_StructMem
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_StructMember &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::StructMember &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -13133,19 +20796,26 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_StructMember &_t
   
 }
 
-CORBA::Boolean  operator<< (
+
+#if !defined _TAO_CDR_OP_IR_StructMemberSeq_I_
+#define _TAO_CDR_OP_IR_StructMemberSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_StructMemberSeq &
+    const IR::StructMemberSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_StructMemberSeq &
+    IR::StructMemberSeq &
   );
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Initializer &_tao_aggregate)
+#endif /* _TAO_CDR_OP_IR_StructMemberSeq_I_ */
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::Initializer &_tao_aggregate)
 {
   if (
-    (strm << _tao_aggregate.members)
+    (strm << _tao_aggregate.members) &&
+    (strm << _tao_aggregate.name.in ())
   )
     return 1;
   else
@@ -13153,10 +20823,11 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Initializ
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_Initializer &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::Initializer &_tao_aggregate)
 {
   if (
-    (strm >> _tao_aggregate.members)
+    (strm >> _tao_aggregate.members) &&
+    (strm >> _tao_aggregate.name.out ())
   )
     return 1;
   else
@@ -13164,16 +20835,22 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_Initializer &_ta
   
 }
 
-CORBA::Boolean  operator<< (
+
+#if !defined _TAO_CDR_OP_IR_InitializerSeq_I_
+#define _TAO_CDR_OP_IR_InitializerSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_InitializerSeq &
+    const IR::InitializerSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_InitializerSeq &
+    IR::InitializerSeq &
   );
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_UnionMember &_tao_aggregate)
+#endif /* _TAO_CDR_OP_IR_InitializerSeq_I_ */
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::UnionMember &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -13187,7 +20864,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_UnionMemb
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_UnionMember &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::UnionMember &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -13201,36 +20878,48 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_UnionMember &_ta
   
 }
 
-CORBA::Boolean  operator<< (
+
+#if !defined _TAO_CDR_OP_IR_UnionMemberSeq_I_
+#define _TAO_CDR_OP_IR_UnionMemberSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_UnionMemberSeq &
+    const IR::UnionMemberSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_UnionMemberSeq &
+    IR::UnionMemberSeq &
   );
 
-CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_UnionMemberSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_IR_EnumMemberSeq_I_
+#define _TAO_CDR_OP_IR_EnumMemberSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_EnumMemberSeq &
+    const IR::EnumMemberSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_EnumMemberSeq &
+    IR::EnumMemberSeq &
   );
 
+#endif /* _TAO_CDR_OP_IR_EnumMemberSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_Container_ptr
+    const IR::Container_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_Container_ptr &
+    IR::Container_ptr &
   );
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Container::Description &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::Container::Description &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.contained_object.in ()) &&
@@ -13243,7 +20932,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Container
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_Container::Description &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::Container::Description &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.contained_object.out ()) &&
@@ -13256,39 +20945,45 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_Container::Descr
   
 }
 
-CORBA::Boolean  operator<< (
+
+#if !defined _TAO_CDR_OP_IR_Container_DescriptionSeq_I_
+#define _TAO_CDR_OP_IR_Container_DescriptionSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_Container::DescriptionSeq &
+    const IR::Container::DescriptionSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_Container::DescriptionSeq &
+    IR::Container::DescriptionSeq &
   );
 
+#endif /* _TAO_CDR_OP_IR_Container_DescriptionSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_Container_ptr _tao_objref
+    const IR::Container_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_Container_ptr &_tao_objref
+    IR::Container_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_Container::_narrow (
+      IR::Container::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13306,38 +21001,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_IDLType_ptr
+    const IR::IDLType_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_IDLType_ptr &
+    IR::IDLType_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_IDLType_ptr _tao_objref
+    const IR::IDLType_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_IDLType_ptr &_tao_objref
+    IR::IDLType_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_IDLType::_narrow (
+      IR::IDLType::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13355,69 +21050,69 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_PrimitiveDef_ptr
+    const IR::PrimitiveDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_PrimitiveDef_ptr &
+    IR::PrimitiveDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_StringDef_ptr
+    const IR::StringDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_StringDef_ptr &
+    IR::StringDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_SequenceDef_ptr
+    const IR::SequenceDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_SequenceDef_ptr &
+    IR::SequenceDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ArrayDef_ptr
+    const IR::ArrayDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ArrayDef_ptr &
+    IR::ArrayDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_WstringDef_ptr
+    const IR::WstringDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_WstringDef_ptr &
+    IR::WstringDef_ptr &
   );
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_FixedDef_ptr
+    const IR::FixedDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_FixedDef_ptr &
+    IR::FixedDef_ptr &
   );
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::PrimitiveKind &_tao_enumval)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::PrimitiveKind &_tao_enumval)
 {
   return strm.write_ulong ((CORBA::ULong) _tao_enumval);
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::PrimitiveKind &_tao_enumval)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::PrimitiveKind &_tao_enumval)
 {
   CORBA::ULong _tao_temp;
   if (strm.read_ulong (_tao_temp))
@@ -13432,38 +21127,38 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::PrimitiveKind &
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_Repository_ptr
+    const IR::Repository_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_Repository_ptr &
+    IR::Repository_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_Repository_ptr _tao_objref
+    const IR::Repository_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_Repository_ptr &_tao_objref
+    IR::Repository_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_Repository::_narrow (
+      IR::Repository::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13481,38 +21176,87 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ModuleDef_ptr
+    const IR::ComponentRepository_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ModuleDef_ptr &
+    IR::ComponentRepository_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ModuleDef_ptr _tao_objref
+    const IR::ComponentRepository_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_ModuleDef_ptr &_tao_objref
+    IR::ComponentRepository_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ComponentRepository::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ModuleDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ModuleDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ModuleDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ModuleDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_ModuleDef::_narrow (
+      IR::ModuleDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13527,7 +21271,7 @@ operator>> (
   return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ModuleDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ModuleDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -13541,7 +21285,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ModuleDes
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ModuleDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ModuleDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -13558,38 +21302,38 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ModuleDescriptio
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ConstantDef_ptr
+    const IR::ConstantDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ConstantDef_ptr &
+    IR::ConstantDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ConstantDef_ptr _tao_objref
+    const IR::ConstantDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_ConstantDef_ptr &_tao_objref
+    IR::ConstantDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_ConstantDef::_narrow (
+      IR::ConstantDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13604,7 +21348,7 @@ operator>> (
   return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ConstantDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ConstantDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -13620,7 +21364,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ConstantD
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ConstantDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ConstantDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -13639,38 +21383,38 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ConstantDescript
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_TypedefDef_ptr
+    const IR::TypedefDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_TypedefDef_ptr &
+    IR::TypedefDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_TypedefDef_ptr _tao_objref
+    const IR::TypedefDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_TypedefDef_ptr &_tao_objref
+    IR::TypedefDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_TypedefDef::_narrow (
+      IR::TypedefDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13685,7 +21429,7 @@ operator>> (
   return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_TypeDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::TypeDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -13700,7 +21444,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_TypeDescr
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_TypeDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::TypeDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -13718,38 +21462,38 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_TypeDescription
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_StructDef_ptr
+    const IR::StructDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_StructDef_ptr &
+    IR::StructDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_StructDef_ptr _tao_objref
+    const IR::StructDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_StructDef_ptr &_tao_objref
+    IR::StructDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_StructDef::_narrow (
+      IR::StructDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13767,38 +21511,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_UnionDef_ptr
+    const IR::UnionDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_UnionDef_ptr &
+    IR::UnionDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_UnionDef_ptr _tao_objref
+    const IR::UnionDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_UnionDef_ptr &_tao_objref
+    IR::UnionDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_UnionDef::_narrow (
+      IR::UnionDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13816,38 +21560,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_EnumDef_ptr
+    const IR::EnumDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_EnumDef_ptr &
+    IR::EnumDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_EnumDef_ptr _tao_objref
+    const IR::EnumDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_EnumDef_ptr &_tao_objref
+    IR::EnumDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_EnumDef::_narrow (
+      IR::EnumDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13865,38 +21609,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_AliasDef_ptr
+    const IR::AliasDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_AliasDef_ptr &
+    IR::AliasDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_AliasDef_ptr _tao_objref
+    const IR::AliasDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_AliasDef_ptr &_tao_objref
+    IR::AliasDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_AliasDef::_narrow (
+      IR::AliasDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13914,38 +21658,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_PrimitiveDef_ptr
+    const IR::NativeDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_PrimitiveDef_ptr &
+    IR::NativeDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_PrimitiveDef_ptr _tao_objref
+    const IR::NativeDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_PrimitiveDef_ptr &_tao_objref
+    IR::NativeDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_PrimitiveDef::_narrow (
+      IR::NativeDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -13963,38 +21707,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_StringDef_ptr
+    const IR::PrimitiveDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_StringDef_ptr &
+    IR::PrimitiveDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_StringDef_ptr _tao_objref
+    const IR::PrimitiveDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_StringDef_ptr &_tao_objref
+    IR::PrimitiveDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_StringDef::_narrow (
+      IR::PrimitiveDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14012,38 +21756,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_WstringDef_ptr
+    const IR::StringDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_WstringDef_ptr &
+    IR::StringDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_WstringDef_ptr _tao_objref
+    const IR::StringDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_WstringDef_ptr &_tao_objref
+    IR::StringDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_WstringDef::_narrow (
+      IR::StringDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14061,38 +21805,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_FixedDef_ptr
+    const IR::WstringDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_FixedDef_ptr &
+    IR::WstringDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_FixedDef_ptr _tao_objref
+    const IR::WstringDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_FixedDef_ptr &_tao_objref
+    IR::WstringDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_FixedDef::_narrow (
+      IR::WstringDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14110,38 +21854,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_SequenceDef_ptr
+    const IR::FixedDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_SequenceDef_ptr &
+    IR::FixedDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_SequenceDef_ptr _tao_objref
+    const IR::FixedDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_SequenceDef_ptr &_tao_objref
+    IR::FixedDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_SequenceDef::_narrow (
+      IR::FixedDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14159,38 +21903,38 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ArrayDef_ptr
+    const IR::SequenceDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ArrayDef_ptr &
+    IR::SequenceDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ArrayDef_ptr _tao_objref
+    const IR::SequenceDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_ArrayDef_ptr &_tao_objref
+    IR::SequenceDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_ArrayDef::_narrow (
+      IR::SequenceDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14208,38 +21952,87 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ExceptionDef_ptr
+    const IR::ArrayDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ExceptionDef_ptr &
+    IR::ArrayDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ExceptionDef_ptr _tao_objref
+    const IR::ArrayDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_ExceptionDef_ptr &_tao_objref
+    IR::ArrayDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ArrayDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ExceptionDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ExceptionDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ExceptionDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ExceptionDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_ExceptionDef::_narrow (
+      IR::ExceptionDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14254,7 +22047,7 @@ operator>> (
   return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ExceptionDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ExceptionDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -14269,7 +22062,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Exception
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ExceptionDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ExceptionDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -14284,12 +22077,42 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ExceptionDescri
   
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::AttributeMode &_tao_enumval)
+
+#if !defined _TAO_CDR_OP_IR_ExceptionDefSeq_I_
+#define _TAO_CDR_OP_IR_ExceptionDefSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ExceptionDefSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::ExceptionDefSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ExceptionDefSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ExcDescriptionSeq_I_
+#define _TAO_CDR_OP_IR_ExcDescriptionSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ExcDescriptionSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::ExcDescriptionSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ExcDescriptionSeq_I_ */
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::AttributeMode &_tao_enumval)
 {
   return strm.write_ulong ((CORBA::ULong) _tao_enumval);
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::AttributeMode &_tao_enumval)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::AttributeMode &_tao_enumval)
 {
   CORBA::ULong _tao_temp;
   if (strm.read_ulong (_tao_temp))
@@ -14304,38 +22127,38 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::AttributeMode &
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_AttributeDef_ptr
+    const IR::AttributeDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_AttributeDef_ptr &
+    IR::AttributeDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_AttributeDef_ptr _tao_objref
+    const IR::AttributeDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_AttributeDef_ptr &_tao_objref
+    IR::AttributeDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_AttributeDef::_narrow (
+      IR::AttributeDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14350,7 +22173,7 @@ operator>> (
   return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::AttributeDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::AttributeDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -14358,7 +22181,9 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::Attribut
     (strm << _tao_aggregate.defined_in.in ()) &&
     (strm << _tao_aggregate.version.in ()) &&
     (strm << _tao_aggregate.type.in ()) &&
-    (strm << _tao_aggregate.mode)
+    (strm << _tao_aggregate.mode) &&
+    (strm << _tao_aggregate.get_exceptions) &&
+    (strm << _tao_aggregate.put_exceptions)
   )
     return 1;
   else
@@ -14366,7 +22191,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::Attribut
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::AttributeDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::AttributeDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -14374,7 +22199,9 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::AttributeDescri
     (strm >> _tao_aggregate.defined_in.out ()) &&
     (strm >> _tao_aggregate.version.out ()) &&
     (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> _tao_aggregate.mode)
+    (strm >> _tao_aggregate.mode) &&
+    (strm >> _tao_aggregate.get_exceptions) &&
+    (strm >> _tao_aggregate.put_exceptions)
   )
     return 1;
   else
@@ -14382,12 +22209,12 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::AttributeDescri
   
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::OperationMode &_tao_enumval)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::OperationMode &_tao_enumval)
 {
   return strm.write_ulong ((CORBA::ULong) _tao_enumval);
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::OperationMode &_tao_enumval)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::OperationMode &_tao_enumval)
 {
   CORBA::ULong _tao_temp;
   if (strm.read_ulong (_tao_temp))
@@ -14399,12 +22226,12 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::OperationMode &
     return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA::ParameterMode &_tao_enumval)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ParameterMode &_tao_enumval)
 {
   return strm.write_ulong ((CORBA::ULong) _tao_enumval);
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ParameterMode &_tao_enumval)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ParameterMode &_tao_enumval)
 {
   CORBA::ULong _tao_temp;
   if (strm.read_ulong (_tao_temp))
@@ -14416,7 +22243,7 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA::ParameterMode &
     return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ParameterDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ParameterDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -14430,7 +22257,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Parameter
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ParameterDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ParameterDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -14444,77 +22271,71 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ParameterDescrip
   
 }
 
-CORBA::Boolean  operator<< (
-    TAO_OutputCDR &,
-    const CORBA_ParDescriptionSeq &
-  );
-CORBA::Boolean  operator>> (
-    TAO_InputCDR &,
-    CORBA_ParDescriptionSeq &
-  );
 
-CORBA::Boolean  operator<< (
-    TAO_OutputCDR &,
-    const CORBA_ContextIdSeq &
-  );
-CORBA::Boolean  operator>> (
-    TAO_InputCDR &,
-    CORBA_ContextIdSeq &
-  );
+#if !defined _TAO_CDR_OP_IR_ParDescriptionSeq_I_
+#define _TAO_CDR_OP_IR_ParDescriptionSeq_I_
 
-CORBA::Boolean  operator<< (
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_ExceptionDefSeq &
+    const IR::ParDescriptionSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_ExceptionDefSeq &
+    IR::ParDescriptionSeq &
   );
 
-CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_ParDescriptionSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_IR_ContextIdSeq_I_
+#define _TAO_CDR_OP_IR_ContextIdSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_ExcDescriptionSeq &
+    const IR::ContextIdSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_ExcDescriptionSeq &
+    IR::ContextIdSeq &
   );
 
+#endif /* _TAO_CDR_OP_IR_ContextIdSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_OperationDef_ptr
+    const IR::OperationDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_OperationDef_ptr &
+    IR::OperationDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_OperationDef_ptr _tao_objref
+    const IR::OperationDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_OperationDef_ptr &_tao_objref
+    IR::OperationDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_OperationDef::_narrow (
+      IR::OperationDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14529,7 +22350,7 @@ operator>> (
   return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_OperationDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::OperationDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -14548,7 +22369,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Operation
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_OperationDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::OperationDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -14567,45 +22388,101 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_OperationDescrip
   
 }
 
-CORBA::Boolean  operator<< (
+
+#if !defined _TAO_CDR_OP_IR_RepositoryIdSeq_I_
+#define _TAO_CDR_OP_IR_RepositoryIdSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_RepositoryIdSeq &
+    const IR::RepositoryIdSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_RepositoryIdSeq &
+    IR::RepositoryIdSeq &
   );
 
-CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_RepositoryIdSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_IR_OpDescriptionSeq_I_
+#define _TAO_CDR_OP_IR_OpDescriptionSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_OpDescriptionSeq &
+    const IR::OpDescriptionSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_OpDescriptionSeq &
+    IR::OpDescriptionSeq &
   );
 
-CORBA::Boolean  operator<< (
+#endif /* _TAO_CDR_OP_IR_OpDescriptionSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_IR_AttrDescriptionSeq_I_
+#define _TAO_CDR_OP_IR_AttrDescriptionSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_AttrDescriptionSeq &
+    const IR::AttrDescriptionSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_AttrDescriptionSeq &
+    IR::AttrDescriptionSeq &
   );
 
+#endif /* _TAO_CDR_OP_IR_AttrDescriptionSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_InterfaceDef_ptr
+    const IR::InterfaceDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_InterfaceDef_ptr &
+    IR::InterfaceDef_ptr &
   );
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_InterfaceDef::FullInterfaceDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::InterfaceDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::InterfaceDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::InterfaceDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::InterfaceDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
@@ -14616,7 +22493,8 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Interface
     (strm << _tao_aggregate.attributes) &&
     (strm << _tao_aggregate.base_interfaces) &&
     (strm << _tao_aggregate.type.in ()) &&
-    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_abstract))
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_abstract)) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_local))
   )
     return 1;
   else
@@ -14624,7 +22502,7 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Interface
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_InterfaceDef::FullInterfaceDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::InterfaceDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
@@ -14635,7 +22513,8 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_InterfaceDef::Fu
     (strm >> _tao_aggregate.attributes) &&
     (strm >> _tao_aggregate.base_interfaces) &&
     (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_abstract))
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_abstract)) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_local))
   )
     return 1;
   else
@@ -14643,30 +22522,139 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_InterfaceDef::Fu
   
 }
 
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ValueMember &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.type.in ()) &&
+    (strm << _tao_aggregate.type_def.in ()) &&
+    (strm << _tao_aggregate.access)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ValueMember &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.type.out ()) &&
+    (strm >> _tao_aggregate.type_def.out ()) &&
+    (strm >> _tao_aggregate.access)
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_IR_ValueMemberSeq_I_
+#define _TAO_CDR_OP_IR_ValueMemberSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ValueMemberSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::ValueMemberSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ValueMemberSeq_I_ */
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ValueMemberDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ValueMemberDef_ptr &
+  );
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_InterfaceDef_ptr _tao_objref
+    const IR::ValueMemberDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_InterfaceDef_ptr &_tao_objref
+    IR::ValueMemberDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ValueMemberDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ValueDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ValueDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ValueDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ValueDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_InterfaceDef::_narrow (
+      IR::ValueDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14681,15 +22669,24 @@ operator>> (
   return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_InterfaceDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ValueDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
     (strm << _tao_aggregate.id.in ()) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_abstract)) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_custom)) &&
     (strm << _tao_aggregate.defined_in.in ()) &&
     (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.base_interfaces) &&
-    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_abstract))
+    (strm << _tao_aggregate.operations) &&
+    (strm << _tao_aggregate.attributes) &&
+    (strm << _tao_aggregate.members) &&
+    (strm << _tao_aggregate.initializers) &&
+    (strm << _tao_aggregate.supported_interfaces) &&
+    (strm << _tao_aggregate.abstract_base_values) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_truncatable)) &&
+    (strm << _tao_aggregate.base_value.in ()) &&
+    (strm << _tao_aggregate.type.in ())
   )
     return 1;
   else
@@ -14697,15 +22694,24 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_Interface
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_InterfaceDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ValueDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
     (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_abstract)) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_custom)) &&
     (strm >> _tao_aggregate.defined_in.out ()) &&
     (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.base_interfaces) &&
-    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_abstract))
+    (strm >> _tao_aggregate.operations) &&
+    (strm >> _tao_aggregate.attributes) &&
+    (strm >> _tao_aggregate.members) &&
+    (strm >> _tao_aggregate.initializers) &&
+    (strm >> _tao_aggregate.supported_interfaces) &&
+    (strm >> _tao_aggregate.abstract_base_values) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_truncatable)) &&
+    (strm >> _tao_aggregate.base_value.out ()) &&
+    (strm >> _tao_aggregate.type.out ())
   )
     return 1;
   else
@@ -14713,16 +22719,112 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_InterfaceDescrip
   
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ValueMember &_tao_aggregate)
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ValueBoxDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ValueBoxDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ValueBoxDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ValueBoxDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ValueBoxDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ProvidesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ProvidesDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ProvidesDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ProvidesDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ProvidesDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ProvidesDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
     (strm << _tao_aggregate.id.in ()) &&
     (strm << _tao_aggregate.defined_in.in ()) &&
     (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.type.in ()) &&
-    (strm << _tao_aggregate.type_def.in ()) &&
-    (strm << _tao_aggregate.access)
+    (strm << _tao_aggregate.interface_type.in ())
   )
     return 1;
   else
@@ -14730,16 +22832,79 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ValueMemb
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ValueMember &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ProvidesDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
     (strm >> _tao_aggregate.id.out ()) &&
     (strm >> _tao_aggregate.defined_in.out ()) &&
     (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.type.out ()) &&
-    (strm >> _tao_aggregate.type_def.out ()) &&
-    (strm >> _tao_aggregate.access)
+    (strm >> _tao_aggregate.interface_type.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::UsesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::UsesDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::UsesDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::UsesDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::UsesDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::UsesDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.interface_type.in ()) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_multiple))
   )
     return 1;
   else
@@ -14747,50 +22912,215 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ValueMember &_ta
   
 }
 
-CORBA::Boolean  operator<< (
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::UsesDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.interface_type.out ()) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_multiple))
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+
+#if !defined _TAO_CDR_OP_IR_ProvidesDescSeq_I_
+#define _TAO_CDR_OP_IR_ProvidesDescSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
+    TAO_OutputCDR &,
+    const IR::ProvidesDescSeq &
+  );
+CORBA::Boolean TAO_Export operator>> (
+    TAO_InputCDR &,
+    IR::ProvidesDescSeq &
+  );
+
+#endif /* _TAO_CDR_OP_IR_ProvidesDescSeq_I_ */
+
+
+#if !defined _TAO_CDR_OP_IR_UsesDescSeq_I_
+#define _TAO_CDR_OP_IR_UsesDescSeq_I_
+
+CORBA::Boolean TAO_Export operator<< (
     TAO_OutputCDR &,
-    const CORBA_ValueMemberSeq &
+    const IR::UsesDescSeq &
   );
-CORBA::Boolean  operator>> (
+CORBA::Boolean TAO_Export operator>> (
     TAO_InputCDR &,
-    CORBA_ValueMemberSeq &
+    IR::UsesDescSeq &
   );
 
+#endif /* _TAO_CDR_OP_IR_UsesDescSeq_I_ */
+
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ValueMemberDef_ptr
+    const IR::EventDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ValueMemberDef_ptr &
+    IR::EventDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ValueMemberDef_ptr _tao_objref
+    const IR::EventDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_ValueMemberDef_ptr &_tao_objref
+    IR::EventDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::EventDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::EventDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.value.in ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::EventDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.value.out ())
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::EmitsDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::EmitsDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::EmitsDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::EmitsDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::EmitsDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::PublishesDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::PublishesDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::PublishesDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::PublishesDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_ValueMemberDef::_narrow (
+      IR::PublishesDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14808,32 +23138,117 @@ operator>> (
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ValueDef_ptr
+    const IR::ConsumesDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ValueDef_ptr &
+    IR::ConsumesDef_ptr &
   );
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ValueDef::FullValueDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ConsumesDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ConsumesDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ConsumesDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::ComponentDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::ComponentDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::ComponentDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::ComponentDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::ComponentDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::ComponentDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
     (strm << _tao_aggregate.id.in ()) &&
-    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_abstract)) &&
-    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_custom)) &&
     (strm << _tao_aggregate.defined_in.in ()) &&
     (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.operations) &&
+    (strm << _tao_aggregate.base_component.in ()) &&
+    (strm << _tao_aggregate.supports_interfaces) &&
+    (strm << _tao_aggregate.provides_interfaces) &&
+    (strm << _tao_aggregate.uses_interfaces) &&
     (strm << _tao_aggregate.attributes) &&
-    (strm << _tao_aggregate.members) &&
-    (strm << _tao_aggregate.initializers) &&
-    (strm << _tao_aggregate.supported_interfaces) &&
-    (strm << _tao_aggregate.abstract_base_values) &&
-    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_truncatable)) &&
-    (strm << _tao_aggregate.base_value.in ()) &&
-    (strm << _tao_aggregate.type.in ())
+    (strm << _tao_aggregate.emits_events) &&
+    (strm << _tao_aggregate.publishes_events) &&
+    (strm << _tao_aggregate.consumes_events) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_basic))
   )
     return 1;
   else
@@ -14841,24 +23256,22 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ValueDef:
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ValueDef::FullValueDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::ComponentDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
     (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_abstract)) &&
-    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_custom)) &&
     (strm >> _tao_aggregate.defined_in.out ()) &&
     (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.operations) &&
+    (strm >> _tao_aggregate.base_component.out ()) &&
+    (strm >> _tao_aggregate.supports_interfaces) &&
+    (strm >> _tao_aggregate.provides_interfaces) &&
+    (strm >> _tao_aggregate.uses_interfaces) &&
     (strm >> _tao_aggregate.attributes) &&
-    (strm >> _tao_aggregate.members) &&
-    (strm >> _tao_aggregate.initializers) &&
-    (strm >> _tao_aggregate.supported_interfaces) &&
-    (strm >> _tao_aggregate.abstract_base_values) &&
-    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_truncatable)) &&
-    (strm >> _tao_aggregate.base_value.out ()) &&
-    (strm >> _tao_aggregate.type.out ())
+    (strm >> _tao_aggregate.emits_events) &&
+    (strm >> _tao_aggregate.publishes_events) &&
+    (strm >> _tao_aggregate.consumes_events) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_basic))
   )
     return 1;
   else
@@ -14868,28 +23281,39 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ValueDef::FullVa
 
 ACE_INLINE CORBA::Boolean
 operator<< (
+    TAO_OutputCDR &,
+    const IR::PrimaryKeyDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::PrimaryKeyDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
     TAO_OutputCDR &strm,
-    const CORBA_ValueDef_ptr _tao_objref
+    const IR::PrimaryKeyDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA_ValueDef_ptr &_tao_objref
+    IR::PrimaryKeyDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_ValueDef::_narrow (
+      IR::PrimaryKeyDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14904,19 +23328,14 @@ operator>> (
   return 0;
 }
 
-ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ValueDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::PrimaryKeyDescription &_tao_aggregate)
 {
   if (
     (strm << _tao_aggregate.name.in ()) &&
     (strm << _tao_aggregate.id.in ()) &&
-    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_abstract)) &&
-    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_custom)) &&
     (strm << _tao_aggregate.defined_in.in ()) &&
     (strm << _tao_aggregate.version.in ()) &&
-    (strm << _tao_aggregate.supported_interface.in ()) &&
-    (strm << _tao_aggregate.abstract_base_values) &&
-    (strm << CORBA_Any::from_boolean (_tao_aggregate.is_truncatable)) &&
-    (strm << _tao_aggregate.base_value.in ())
+    (strm << _tao_aggregate.primary_key.in ())
   )
     return 1;
   else
@@ -14924,19 +23343,14 @@ ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const CORBA_ValueDesc
   
 }
 
-ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ValueDescription &_tao_aggregate)
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::PrimaryKeyDescription &_tao_aggregate)
 {
   if (
     (strm >> _tao_aggregate.name.out ()) &&
     (strm >> _tao_aggregate.id.out ()) &&
-    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_abstract)) &&
-    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_custom)) &&
     (strm >> _tao_aggregate.defined_in.out ()) &&
     (strm >> _tao_aggregate.version.out ()) &&
-    (strm >> _tao_aggregate.supported_interface.out ()) &&
-    (strm >> _tao_aggregate.abstract_base_values) &&
-    (strm >> CORBA_Any::to_boolean (_tao_aggregate.is_truncatable)) &&
-    (strm >> _tao_aggregate.base_value.out ())
+    (strm >> _tao_aggregate.primary_key.out ())
   )
     return 1;
   else
@@ -14947,38 +23361,87 @@ ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, CORBA_ValueDescription
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &,
-    const CORBA_ValueBoxDef_ptr
+    const IR::FactoryDef_ptr
   );
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &,
-    CORBA_ValueBoxDef_ptr &
+    IR::FactoryDef_ptr &
   );
 
 ACE_INLINE CORBA::Boolean
 operator<< (
     TAO_OutputCDR &strm,
-    const CORBA::ValueBoxDef_ptr _tao_objref
+    const IR::FactoryDef_ptr _tao_objref
   )
 {
-  CORBA_Object_ptr _tao_corba_obj = _tao_objref;
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
   return (strm << _tao_corba_obj);
 }
 
 ACE_INLINE CORBA::Boolean
 operator>> (
     TAO_InputCDR &strm,
-    CORBA::ValueBoxDef_ptr &_tao_objref
+    IR::FactoryDef_ptr &_tao_objref
   )
 {
   ACE_TRY_NEW_ENV
   {
-    CORBA_Object_var obj;
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::FactoryDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::FinderDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::FinderDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::FinderDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::FinderDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
     if ((strm >> obj.inout ()) == 0)
       return 0;
     // narrow to the right type
     _tao_objref =
-      CORBA_ValueBoxDef::_narrow (
+      IR::FinderDef::_narrow (
           obj.in (),
           ACE_TRY_ENV
         );
@@ -14993,4 +23456,145 @@ operator>> (
   return 0;
 }
 
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const IR::HomeDef_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    IR::HomeDef_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const IR::HomeDef_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    IR::HomeDef_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      IR::HomeDef::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
+
+ACE_INLINE CORBA::Boolean operator<< (TAO_OutputCDR &strm, const IR::HomeDescription &_tao_aggregate)
+{
+  if (
+    (strm << _tao_aggregate.name.in ()) &&
+    (strm << _tao_aggregate.id.in ()) &&
+    (strm << _tao_aggregate.defined_in.in ()) &&
+    (strm << _tao_aggregate.version.in ()) &&
+    (strm << _tao_aggregate.base_home.in ()) &&
+    (strm << _tao_aggregate.managed_component.in ()) &&
+    (strm << _tao_aggregate.primary_key_def.in ()) &&
+    (strm << _tao_aggregate.factories) &&
+    (strm << _tao_aggregate.finders) &&
+    (strm << _tao_aggregate.operations) &&
+    (strm << _tao_aggregate.attributes) &&
+    (strm << CORBA::Any::from_boolean (_tao_aggregate.is_basic))
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean operator>> (TAO_InputCDR &strm, IR::HomeDescription &_tao_aggregate)
+{
+  if (
+    (strm >> _tao_aggregate.name.out ()) &&
+    (strm >> _tao_aggregate.id.out ()) &&
+    (strm >> _tao_aggregate.defined_in.out ()) &&
+    (strm >> _tao_aggregate.version.out ()) &&
+    (strm >> _tao_aggregate.base_home.out ()) &&
+    (strm >> _tao_aggregate.managed_component.out ()) &&
+    (strm >> _tao_aggregate.primary_key_def.out ()) &&
+    (strm >> _tao_aggregate.factories) &&
+    (strm >> _tao_aggregate.finders) &&
+    (strm >> _tao_aggregate.operations) &&
+    (strm >> _tao_aggregate.attributes) &&
+    (strm >> CORBA::Any::to_boolean (_tao_aggregate.is_basic))
+  )
+    return 1;
+  else
+    return 0;
+  
+}
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &,
+    const CORBA_TypeCodeFactory_ptr
+  );
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &,
+    CORBA_TypeCodeFactory_ptr &
+  );
+
+ACE_INLINE CORBA::Boolean
+operator<< (
+    TAO_OutputCDR &strm,
+    const CORBA_TypeCodeFactory_ptr _tao_objref
+  )
+{
+  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
+  return (strm << _tao_corba_obj);
+}
+
+ACE_INLINE CORBA::Boolean
+operator>> (
+    TAO_InputCDR &strm,
+    CORBA_TypeCodeFactory_ptr &_tao_objref
+  )
+{
+  ACE_TRY_NEW_ENV
+  {
+    CORBA::Object_var obj;
+    if ((strm >> obj.inout ()) == 0)
+      return 0;
+    // narrow to the right type
+    _tao_objref =
+      CORBA_TypeCodeFactory::_narrow (
+          obj.in (),
+          ACE_TRY_ENV
+        );
+    ACE_TRY_CHECK;
+    return 1;
+  }
+  ACE_CATCHANY
+  {
+    // do nothing
+  }
+  ACE_ENDTRY;
+  return 0;
+}
 
diff --git a/TAO/tao/InterfaceS.cpp b/TAO/tao/InterfaceS.cpp
index 95db47905ec..ce06b773507 100644
--- a/TAO/tao/InterfaceS.cpp
+++ b/TAO/tao/InterfaceS.cpp
@@ -14,10 +14,6 @@ ACE_RCSID(tao, InterfaceS, "$Id$")
 
 #if (TAO_HAS_INTERFACE_REPOSITORY == 1)
 
-#if !defined (__ACE_INLINE__)
-#include "tao/InterfaceS.i"
-#endif /* !defined INLINE */
-
 class TAO_CORBA_IRObject_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
 {
 private:
@@ -185,8 +181,8 @@ void POA_CORBA::IRObject::_get_def_kind_skel (
 {
   POA_CORBA::IRObject *_tao_impl = (POA_CORBA::IRObject *)_tao_object_reference;
 
-  CORBA::DefinitionKind _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
+  IR::DefinitionKind _tao_retval;
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -223,7 +219,7 @@ void POA_CORBA::IRObject::_get_def_kind_skel (
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
@@ -271,7 +267,7 @@ void POA_CORBA::IRObject::destroy_skel (
 {
   POA_CORBA::IRObject *_tao_impl = (POA_CORBA::IRObject *)_tao_object_reference;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -308,7 +304,7 @@ void POA_CORBA::IRObject::destroy_skel (
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
@@ -513,14 +509,14 @@ CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_IRObject::_non_existent(
 }
 
 
-CORBA::DefinitionKind POA_CORBA::_tao_thru_poa_collocated_IRObject::def_kind  (
+IR::DefinitionKind POA_CORBA::_tao_thru_poa_collocated_IRObject::def_kind  (
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::DefinitionKind _tao_retval;
+  IR::DefinitionKind _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
@@ -569,108 +565,111 @@ void POA_CORBA::_tao_thru_poa_collocated_IRObject::destroy  (
   return;
 }
 
-
-
-class TAO_CORBA_Contained_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
+class TAO_CORBA_TypeCodeFactory_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
 {
 private:
   unsigned int hash (const char *str, unsigned int len);
 public:
  const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
 };
-/* starting time is 22:05:52 */
+/* starting time is 15:29:12 */
 /* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_Contained_Perfect_Hash_OpTable -N lookup  */
+/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_TypeCodeFactory_Perfect_Hash_OpTable -N lookup  */
 unsigned int
-TAO_CORBA_Contained_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
+TAO_CORBA_TypeCodeFactory_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
 {
   static const unsigned char asso_values[] =
     {
 #if defined (ACE_MVS)
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37,  0,  0, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37,  0,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 10, 37, 37, 37, 37, 10, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29,  0,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29,  0,
+     29,  0, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29,  0, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29,
 #else
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37,  0, 37,  0, 37, 37,
-      0,  0, 37, 37, 37, 37, 37, 37, 37,  0,
-      0, 37, 37, 37, 37, 37, 10, 37, 37, 37,
-     37, 10, 37, 37, 37, 37, 37, 37,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29,  0, 29,  0, 29,  0,
+     29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+     29, 29, 29, 29, 29, 29,  0, 29, 29, 29,
+     29, 29, 29, 29, 29, 29, 29, 29,
 #endif /* ACE_MVS */
     };
   return len + asso_values[str[len - 1]] + asso_values[str[0]];
 }
 
 const class TAO_operation_db_entry *
-TAO_CORBA_Contained_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
+TAO_CORBA_TypeCodeFactory_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
 {
   enum
     {
-      TOTAL_KEYWORDS = 15,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 36,
-      HASH_VALUE_RANGE = 33,
-      DUPLICATES = 4
+      TOTAL_KEYWORDS = 20,
+      MIN_WORD_LENGTH = 5,
+      MAX_WORD_LENGTH = 28,
+      MIN_HASH_VALUE = 5,
+      MAX_HASH_VALUE = 28,
+      HASH_VALUE_RANGE = 24,
+      DUPLICATES = 12
     };
 
   static const class TAO_operation_db_entry  wordlist[] =
     {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::Contained::move_skel},
-      {"_is_a",  &POA_CORBA::Contained::_is_a_skel},
-      {"_get_id", 	&POA_CORBA::Contained::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::Contained::_set_id_skel},
-      {"describe", 	&POA_CORBA::Contained::describe_skel},
-      {"_get_name", 	&POA_CORBA::Contained::_get_name_skel},
-      {"_set_name", 	&POA_CORBA::Contained::_set_name_skel},
-      {"_get_version", 	&POA_CORBA::Contained::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::Contained::_set_version_skel},
-      {"_get_def_kind", 	&POA_CORBA::Contained::_get_def_kind_skel},
-      {"_get_defined_in", 	&POA_CORBA::Contained::_get_defined_in_skel},
-      {"destroy", 	&POA_CORBA::Contained::destroy_skel},
-      {"_get_absolute_name", 	&POA_CORBA::Contained::_get_absolute_name_skel},
-      {"_non_existent",  &POA_CORBA::Contained::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::Contained::_get_containing_repository_skel},
+      {"",0},{"",0},{"",0},{"",0},{"",0},
+      {"_is_a",  &POA_CORBA::TypeCodeFactory::_is_a_skel},
+      {"_non_existent",  &POA_CORBA::TypeCodeFactory::_non_existent_skel},
+      {"create_enum_tc", 	&POA_CORBA::TypeCodeFactory::create_enum_tc_skel},
+      {"create_home_tc", 	&POA_CORBA::TypeCodeFactory::create_home_tc_skel},
+      {"create_union_tc", 	&POA_CORBA::TypeCodeFactory::create_union_tc_skel},
+      {"create_value_tc", 	&POA_CORBA::TypeCodeFactory::create_value_tc_skel},
+      {"create_array_tc", 	&POA_CORBA::TypeCodeFactory::create_array_tc_skel},
+      {"create_fixed_tc", 	&POA_CORBA::TypeCodeFactory::create_fixed_tc_skel},
+      {"create_alias_tc", 	&POA_CORBA::TypeCodeFactory::create_alias_tc_skel},
+      {"create_struct_tc", 	&POA_CORBA::TypeCodeFactory::create_struct_tc_skel},
+      {"create_native_tc", 	&POA_CORBA::TypeCodeFactory::create_native_tc_skel},
+      {"create_string_tc", 	&POA_CORBA::TypeCodeFactory::create_string_tc_skel},
+      {"create_wstring_tc", 	&POA_CORBA::TypeCodeFactory::create_wstring_tc_skel},
+      {"create_sequence_tc", 	&POA_CORBA::TypeCodeFactory::create_sequence_tc_skel},
+      {"create_exception_tc", 	&POA_CORBA::TypeCodeFactory::create_exception_tc_skel},
+      {"create_component_tc", 	&POA_CORBA::TypeCodeFactory::create_component_tc_skel},
+      {"create_recursive_tc", 	&POA_CORBA::TypeCodeFactory::create_recursive_tc_skel},
+      {"create_value_box_tc", 	&POA_CORBA::TypeCodeFactory::create_value_box_tc_skel},
+      {"create_interface_tc", 	&POA_CORBA::TypeCodeFactory::create_interface_tc_skel},
+      {"create_abstract_interface_tc", 	&POA_CORBA::TypeCodeFactory::create_abstract_interface_tc_skel},
     };
 
   static const signed char lookup[] =
     {
-       -6,  -2,  -9,  -2,   4,   5,  -1, -43,   8, -43, -11,  -2, -38,  13, 
-       -1,  14,  -1,  15,  16,  -1,  -1,  -1,  -1,  17,  -1,  -1,  -1,  -1, 
-       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  18, 
+       -1,  -1,  -1,  -7,  -2,   5,  -1,  -9,  -5, -14,  -3, -19,  -5,   6, 
+      -39, -36, -35,  17,  18, -36,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 
+       24, 
     };
 
   if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
@@ -704,10 +703,10 @@ TAO_CORBA_Contained_Perfect_Hash_OpTable::lookup (const char *str, unsigned int
     }
   return 0;
 }
-/* ending time is 22:05:52 */
-static TAO_CORBA_Contained_Perfect_Hash_OpTable tao_CORBA_Contained_optable;
+/* ending time is 15:29:12 */
+static TAO_CORBA_TypeCodeFactory_Perfect_Hash_OpTable tao_CORBA_TypeCodeFactory_optable;
 
-CORBA::Contained_ptr _TAO_collocation_POA_CORBA_Contained_Stub_Factory (
+CORBA::TypeCodeFactory_ptr _TAO_collocation_POA_CORBA_TypeCodeFactory_Stub_Factory (
     CORBA::Object_ptr obj
   )
 {
@@ -717,10 +716,10 @@ CORBA::Contained_ptr _TAO_collocation_POA_CORBA_Contained_Stub_Factory (
     {
     case TAO_ORB_Core::THRU_POA:
       {
-      CORBA::Contained_ptr retval = 0;
+      CORBA::TypeCodeFactory_ptr retval = 0;
       ACE_NEW_RETURN (
           retval,
-          POA_CORBA::_tao_thru_poa_collocated_Contained (stub),
+          POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory (stub),
           0
         );
       return retval;
@@ -733,123 +732,36 @@ CORBA::Contained_ptr _TAO_collocation_POA_CORBA_Contained_Stub_Factory (
   return 0;
 }
 
-int _TAO_collocation_POA_CORBA_Contained_Stub_Factory_Initializer (long dummy)
+int _TAO_collocation_POA_CORBA_TypeCodeFactory_Stub_Factory_Initializer (long dummy)
 {
   ACE_UNUSED_ARG (dummy);
   
-  _TAO_collocation_CORBA_Contained_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_Contained_Stub_Factory;
+  _TAO_collocation_CORBA_TypeCodeFactory_Stub_Factory_function_pointer = 
+    _TAO_collocation_POA_CORBA_TypeCodeFactory_Stub_Factory;
   
   return 0;
 }
 
-static int _TAO_collocation_POA_CORBA_Contained_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_Contained_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_Contained_Stub_Factory_Initializer));
+static int _TAO_collocation_POA_CORBA_TypeCodeFactory_Stub_Factory_Initializer_Scarecrow = 
+  _TAO_collocation_POA_CORBA_TypeCodeFactory_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_TypeCodeFactory_Stub_Factory_Initializer));
 
 // skeleton constructor
-POA_CORBA::Contained::Contained (void)
+POA_CORBA::TypeCodeFactory::TypeCodeFactory (void)
 {
-  this->optable_ = &tao_CORBA_Contained_optable;
+  this->optable_ = &tao_CORBA_TypeCodeFactory_optable;
 }
 
 // copy ctor
-POA_CORBA::Contained::Contained (const Contained& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
+POA_CORBA::TypeCodeFactory::TypeCodeFactory (const TypeCodeFactory& rhs)
+  :   TAO_ServantBase (rhs)
 {}
 
 // skeleton destructor
-POA_CORBA::Contained::~Contained (void)
+POA_CORBA::TypeCodeFactory::~TypeCodeFactory (void)
 {
 }
 
-void POA_CORBA::Contained::_get_id_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
-
-  CORBA::String_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_id",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->id (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_id",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_id",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::Contained::_set_id_skel (
+void POA_CORBA::TypeCodeFactory::create_struct_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -857,15 +769,20 @@ void POA_CORBA::Contained::_set_id_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
+  CORBA::TypeCode_var _tao_retval;
   CORBA::String_var id;
+  CORBA::String_var name;
+  IR::StructMemberSeq members;
   if (!(
-    (_tao_in >> id.out ())
+    (_tao_in >> id.out ()) &&
+    (_tao_in >> name.out ()) &&
+    (_tao_in >> members)
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -887,7 +804,7 @@ void POA_CORBA::Contained::_set_id_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "_set_id",
+          "create_struct_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -896,99 +813,21 @@ void POA_CORBA::Contained::_set_id_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_impl->id (
+      _tao_retval = _tao_impl->create_struct_tc (
         id.in (),
+        name.in (),
+        members,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_id",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_id",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::Contained::_get_name_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
-
-  CORBA::String_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_name",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->name (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "_get_name",
+          "create_struct_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -1002,7 +841,7 @@ void POA_CORBA::Contained::_get_name_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "_get_name",
+          "create_struct_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -1022,7 +861,7 @@ void POA_CORBA::Contained::_get_name_skel (
 
 }
 
-void POA_CORBA::Contained::_set_name_skel (
+void POA_CORBA::TypeCodeFactory::create_union_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -1030,15 +869,22 @@ void POA_CORBA::Contained::_set_name_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::String_var id;
   CORBA::String_var name;
+  CORBA::TypeCode_var discriminator_type;
+  IR::UnionMemberSeq members;
   if (!(
-    (_tao_in >> name.out ())
+    (_tao_in >> id.out ()) &&
+    (_tao_in >> name.out ()) &&
+    (_tao_in >> discriminator_type.out ()) &&
+    (_tao_in >> members)
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -1060,7 +906,7 @@ void POA_CORBA::Contained::_set_name_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "_set_name",
+          "create_union_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -1069,99 +915,22 @@ void POA_CORBA::Contained::_set_name_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_impl->name (
+      _tao_retval = _tao_impl->create_union_tc (
+        id.in (),
         name.in (),
+        discriminator_type.in (),
+        members,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_name",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_name",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::Contained::_get_version_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
-
-  CORBA::String_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_version",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->version (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "_get_version",
+          "create_union_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -1175,7 +944,7 @@ void POA_CORBA::Contained::_get_version_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "_get_version",
+          "create_union_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -1195,7 +964,7 @@ void POA_CORBA::Contained::_get_version_skel (
 
 }
 
-void POA_CORBA::Contained::_set_version_skel (
+void POA_CORBA::TypeCodeFactory::create_enum_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -1203,182 +972,20 @@ void POA_CORBA::Contained::_set_version_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
-
-  CORBA::String_var version;
-  if (!(
-    (_tao_in >> version.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_version",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->version (
-        version.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_version",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_version",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::Contained::_get_defined_in_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
-
-  CORBA::Container_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_defined_in",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->defined_in (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_defined_in",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_defined_in",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::String_var id;
+  CORBA::String_var name;
+  IR::EnumMemberSeq members;
   if (!(
-    (_tao_out << _tao_retval.in ())
+    (_tao_in >> id.out ()) &&
+    (_tao_in >> name.out ()) &&
+    (_tao_in >> members)
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-}
-
-void POA_CORBA::Contained::_get_absolute_name_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
-
-  CORBA::String_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -1400,7 +1007,7 @@ void POA_CORBA::Contained::_get_absolute_name_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "_get_absolute_name",
+          "create_enum_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -1409,18 +1016,21 @@ void POA_CORBA::Contained::_get_absolute_name_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->absolute_name (
+      _tao_retval = _tao_impl->create_enum_tc (
+        id.in (),
+        name.in (),
+        members,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "_get_absolute_name",
+          "create_enum_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -1434,7 +1044,7 @@ void POA_CORBA::Contained::_get_absolute_name_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "_get_absolute_name",
+          "create_enum_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -1454,103 +1064,28 @@ void POA_CORBA::Contained::_get_absolute_name_skel (
 
 }
 
-void POA_CORBA::Contained::_get_containing_repository_skel (
+void POA_CORBA::TypeCodeFactory::create_alias_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
     CORBA::Environment &ACE_TRY_ENV
 )
 {
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
-
-  CORBA::Repository_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_containing_repository",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->containing_repository (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_containing_repository",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_containing_repository",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
+  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::String_var id;
+  CORBA::String_var name;
+  CORBA::TypeCode_var original_type;
   if (!(
-    (_tao_out << _tao_retval.in ())
+    (_tao_in >> id.out ()) &&
+    (_tao_in >> name.out ()) &&
+    (_tao_in >> original_type.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-}
-
-void POA_CORBA::Contained::describe_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
-
-  CORBA::Contained::Description_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -1572,7 +1107,7 @@ void POA_CORBA::Contained::describe_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "describe",
+          "create_alias_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -1581,18 +1116,21 @@ void POA_CORBA::Contained::describe_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->describe (
+      _tao_retval = _tao_impl->create_alias_tc (
+        id.in (),
+        name.in (),
+        original_type.in (),
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "describe",
+          "create_alias_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -1606,7 +1144,7 @@ void POA_CORBA::Contained::describe_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "describe",
+          "create_alias_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -1626,778 +1164,7 @@ void POA_CORBA::Contained::describe_skel (
 
 }
 
-void POA_CORBA::Contained::move_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *)_tao_object_reference;
-
-  CORBA::Container_var new_container;
-  CORBA::String_var new_name;
-  CORBA::String_var new_version;
-  if (!(
-    (_tao_in >> new_container.out ()) &&
-    (_tao_in >> new_name.out ()) &&
-    (_tao_in >> new_version.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "move",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->move (
-        new_container.in (),
-        new_name.in (),
-        new_version.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "move",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "move",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::Contained::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::Contained::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::Contained *_tao_impl = (POA_CORBA::Contained *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::Contained::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::Contained::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::Contained::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::Contained::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/Contained:1.0";
-}
-
-CORBA::Contained*
-POA_CORBA::Contained::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::Contained_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_Contained (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::Contained::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_Contained::_tao_thru_poa_collocated_Contained (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_Contained::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_Contained::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-char * POA_CORBA::_tao_thru_poa_collocated_Contained::id  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::String_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "id",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->id (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_Contained::id  (
-    const char * id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "id",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->id (
-      id,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-char * POA_CORBA::_tao_thru_poa_collocated_Contained::name  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::String_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "name",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->name (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_Contained::name  (
-    const char * name,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "name",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->name (
-      name,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-char * POA_CORBA::_tao_thru_poa_collocated_Contained::version  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::String_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "version",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->version (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_Contained::version  (
-    const char * version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "version",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->version (
-      version,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::Container_ptr POA_CORBA::_tao_thru_poa_collocated_Contained::defined_in  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Container_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "defined_in",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->defined_in (
-      ACE_TRY_ENV
-    );
-
-}
-
-char * POA_CORBA::_tao_thru_poa_collocated_Contained::absolute_name  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::String_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "absolute_name",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->absolute_name (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::Repository_ptr POA_CORBA::_tao_thru_poa_collocated_Contained::containing_repository  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Repository_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "containing_repository",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->containing_repository (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::Contained::Description * POA_CORBA::_tao_thru_poa_collocated_Contained::describe  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Contained::Description_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "describe",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->describe (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_Contained::move  (
-    CORBA::Container_ptr new_container,
-    const char * new_name,
-    const char * new_version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "move",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::Contained_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Contained:1.0"
-        )
-    )->move (
-      new_container,
-      new_name,
-      new_version,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_Container_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:52 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_Container_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_Container_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 15,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39,  0,
-     39,  0,  0,  0, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39,  0, 20,  5,
-     39,  0, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 10, 10, 39, 39, 39, 10,  0, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39,
-#else
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 39, 39, 39, 39, 39,
-     39, 39, 39, 39, 39, 15, 39,  0, 39,  0,
-      0,  0, 39, 39, 39, 39, 39, 39,  0, 20,
-      5, 39,  0, 39, 39, 10, 10, 39, 39, 39,
-     10,  0, 39, 39, 39, 39, 39, 39,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_Container_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 18,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 17,
-      MIN_HASH_VALUE = 6,
-      MAX_HASH_VALUE = 38,
-      HASH_VALUE_RANGE = 33,
-      DUPLICATES = 0
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},{"",0},
-      {"lookup", 	&POA_CORBA::Container::lookup_skel},
-      {"destroy", 	&POA_CORBA::Container::destroy_skel},
-      {"",0},{"",0},{"",0},
-      {"lookup_name", 	&POA_CORBA::Container::lookup_name_skel},
-      {"create_value", 	&POA_CORBA::Container::create_value_skel},
-      {"create_module", 	&POA_CORBA::Container::create_module_skel},
-      {"",0},{"",0},
-      {"create_interface", 	&POA_CORBA::Container::create_interface_skel},
-      {"create_union", 	&POA_CORBA::Container::create_union_skel},
-      {"contents", 	&POA_CORBA::Container::contents_skel},
-      {"",0},
-      {"_is_a",  &POA_CORBA::Container::_is_a_skel},
-      {"create_exception", 	&POA_CORBA::Container::create_exception_skel},
-      {"create_alias", 	&POA_CORBA::Container::create_alias_skel},
-      {"create_struct", 	&POA_CORBA::Container::create_struct_skel},
-      {"",0},
-      {"create_constant", 	&POA_CORBA::Container::create_constant_skel},
-      {"create_value_box", 	&POA_CORBA::Container::create_value_box_skel},
-      {"describe_contents", 	&POA_CORBA::Container::describe_contents_skel},
-      {"_get_def_kind", 	&POA_CORBA::Container::_get_def_kind_skel},
-      {"",0},{"",0},
-      {"create_enum", 	&POA_CORBA::Container::create_enum_skel},
-      {"",0},{"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_non_existent",  &POA_CORBA::Container::_non_existent_skel},
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          const char *s = wordlist[key].opname_;
-
-          if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-            return &wordlist[key];
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:52 */
-static TAO_CORBA_Container_Perfect_Hash_OpTable tao_CORBA_Container_optable;
-
-CORBA::Container_ptr _TAO_collocation_POA_CORBA_Container_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::Container_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_Container (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_Container_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_Container_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_Container_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_Container_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_Container_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_Container_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::Container::Container (void)
-{
-  this->optable_ = &tao_CORBA_Container_optable;
-}
-
-// copy ctor
-POA_CORBA::Container::Container (const Container& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::Container::~Container (void)
-{
-}
-
-void POA_CORBA::Container::lookup_skel (
+void POA_CORBA::TypeCodeFactory::create_exception_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -2405,16 +1172,20 @@ void POA_CORBA::Container::lookup_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::Contained_var _tao_retval;
-  CORBA::String_var search_name;
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::String_var id;
+  CORBA::String_var name;
+  IR::StructMemberSeq members;
   if (!(
-    (_tao_in >> search_name.out ())
+    (_tao_in >> id.out ()) &&
+    (_tao_in >> name.out ()) &&
+    (_tao_in >> members)
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -2436,7 +1207,7 @@ void POA_CORBA::Container::lookup_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "lookup",
+          "create_exception_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2445,19 +1216,21 @@ void POA_CORBA::Container::lookup_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->lookup (
-        search_name.in (),
+      _tao_retval = _tao_impl->create_exception_tc (
+        id.in (),
+        name.in (),
+        members,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "lookup",
+          "create_exception_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2471,7 +1244,7 @@ void POA_CORBA::Container::lookup_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "lookup",
+          "create_exception_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -2491,7 +1264,7 @@ void POA_CORBA::Container::lookup_skel (
 
 }
 
-void POA_CORBA::Container::contents_skel (
+void POA_CORBA::TypeCodeFactory::create_interface_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -2499,18 +1272,18 @@ void POA_CORBA::Container::contents_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::ContainedSeq_var _tao_retval;
-  CORBA::DefinitionKind limit_type;
-  CORBA::Boolean exclude_inherited;
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::String_var id;
+  CORBA::String_var name;
   if (!(
-    (_tao_in >> limit_type) &&
-    (_tao_in >> CORBA::Any::to_boolean (exclude_inherited))
+    (_tao_in >> id.out ()) &&
+    (_tao_in >> name.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -2532,7 +1305,7 @@ void POA_CORBA::Container::contents_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "contents",
+          "create_interface_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2541,20 +1314,20 @@ void POA_CORBA::Container::contents_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->contents (
-        limit_type,
-        exclude_inherited,
+      _tao_retval = _tao_impl->create_interface_tc (
+        id.in (),
+        name.in (),
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "contents",
+          "create_interface_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2568,7 +1341,7 @@ void POA_CORBA::Container::contents_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "contents",
+          "create_interface_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -2588,7 +1361,7 @@ void POA_CORBA::Container::contents_skel (
 
 }
 
-void POA_CORBA::Container::lookup_name_skel (
+void POA_CORBA::TypeCodeFactory::create_string_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -2596,22 +1369,16 @@ void POA_CORBA::Container::lookup_name_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::ContainedSeq_var _tao_retval;
-  CORBA::String_var search_name;
-  CORBA::Long levels_to_search;
-  CORBA::DefinitionKind limit_type;
-  CORBA::Boolean exclude_inherited;
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::ULong bound;
   if (!(
-    (_tao_in >> search_name.out ()) &&
-    (_tao_in >> levels_to_search) &&
-    (_tao_in >> limit_type) &&
-    (_tao_in >> CORBA::Any::to_boolean (exclude_inherited))
+    (_tao_in >> bound)
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -2633,7 +1400,7 @@ void POA_CORBA::Container::lookup_name_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "lookup_name",
+          "create_string_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2642,22 +1409,19 @@ void POA_CORBA::Container::lookup_name_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->lookup_name (
-        search_name.in (),
-        levels_to_search,
-        limit_type,
-        exclude_inherited,
+      _tao_retval = _tao_impl->create_string_tc (
+        bound,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "lookup_name",
+          "create_string_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2671,7 +1435,7 @@ void POA_CORBA::Container::lookup_name_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "lookup_name",
+          "create_string_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -2691,7 +1455,7 @@ void POA_CORBA::Container::lookup_name_skel (
 
 }
 
-void POA_CORBA::Container::describe_contents_skel (
+void POA_CORBA::TypeCodeFactory::create_wstring_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -2699,20 +1463,16 @@ void POA_CORBA::Container::describe_contents_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::Container::DescriptionSeq_var _tao_retval;
-  CORBA::DefinitionKind limit_type;
-  CORBA::Boolean exclude_inherited;
-  CORBA::Long max_returned_objs;
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::ULong bound;
   if (!(
-    (_tao_in >> limit_type) &&
-    (_tao_in >> CORBA::Any::to_boolean (exclude_inherited)) &&
-    (_tao_in >> max_returned_objs)
+    (_tao_in >> bound)
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -2734,7 +1494,7 @@ void POA_CORBA::Container::describe_contents_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "describe_contents",
+          "create_wstring_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2743,21 +1503,19 @@ void POA_CORBA::Container::describe_contents_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->describe_contents (
-        limit_type,
-        exclude_inherited,
-        max_returned_objs,
+      _tao_retval = _tao_impl->create_wstring_tc (
+        bound,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "describe_contents",
+          "create_wstring_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2771,7 +1529,7 @@ void POA_CORBA::Container::describe_contents_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "describe_contents",
+          "create_wstring_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -2791,7 +1549,7 @@ void POA_CORBA::Container::describe_contents_skel (
 
 }
 
-void POA_CORBA::Container::create_module_skel (
+void POA_CORBA::TypeCodeFactory::create_fixed_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -2799,20 +1557,18 @@ void POA_CORBA::Container::create_module_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::ModuleDef_var _tao_retval;
-  CORBA::String_var id;
-  CORBA::String_var name;
-  CORBA::String_var version;
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::UShort digits;
+  CORBA::UShort scale;
   if (!(
-    (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ())
+    (_tao_in >> digits) &&
+    (_tao_in >> scale)
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -2834,7 +1590,7 @@ void POA_CORBA::Container::create_module_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_module",
+          "create_fixed_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2843,21 +1599,20 @@ void POA_CORBA::Container::create_module_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_module (
-        id.in (),
-        name.in (),
-        version.in (),
+      _tao_retval = _tao_impl->create_fixed_tc (
+        digits,
+        scale,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_module",
+          "create_fixed_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2871,7 +1626,7 @@ void POA_CORBA::Container::create_module_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_module",
+          "create_fixed_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -2891,7 +1646,7 @@ void POA_CORBA::Container::create_module_skel (
 
 }
 
-void POA_CORBA::Container::create_constant_skel (
+void POA_CORBA::TypeCodeFactory::create_sequence_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -2899,24 +1654,18 @@ void POA_CORBA::Container::create_constant_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::ConstantDef_var _tao_retval;
-  CORBA::String_var id;
-  CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::IDLType_var type;
-  CORBA::Any value;
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::ULong bound;
+  CORBA::TypeCode_var element_type;
   if (!(
-    (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> type.out ()) &&
-    (_tao_in >> value)
+    (_tao_in >> bound) &&
+    (_tao_in >> element_type.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -2938,7 +1687,7 @@ void POA_CORBA::Container::create_constant_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_constant",
+          "create_sequence_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2947,23 +1696,20 @@ void POA_CORBA::Container::create_constant_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_constant (
-        id.in (),
-        name.in (),
-        version.in (),
-        type.in (),
-        value,
+      _tao_retval = _tao_impl->create_sequence_tc (
+        bound,
+        element_type.in (),
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_constant",
+          "create_sequence_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -2977,7 +1723,7 @@ void POA_CORBA::Container::create_constant_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_constant",
+          "create_sequence_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -2997,7 +1743,7 @@ void POA_CORBA::Container::create_constant_skel (
 
 }
 
-void POA_CORBA::Container::create_struct_skel (
+void POA_CORBA::TypeCodeFactory::create_array_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -3005,22 +1751,18 @@ void POA_CORBA::Container::create_struct_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::StructDef_var _tao_retval;
-  CORBA::String_var id;
-  CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::StructMemberSeq members;
+  CORBA::TypeCode_var _tao_retval;
+  CORBA::ULong length;
+  CORBA::TypeCode_var element_type;
   if (!(
-    (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> members)
+    (_tao_in >> length) &&
+    (_tao_in >> element_type.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -3042,7 +1784,7 @@ void POA_CORBA::Container::create_struct_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_struct",
+          "create_array_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3051,22 +1793,20 @@ void POA_CORBA::Container::create_struct_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_struct (
-        id.in (),
-        name.in (),
-        version.in (),
-        members,
+      _tao_retval = _tao_impl->create_array_tc (
+        length,
+        element_type.in (),
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_struct",
+          "create_array_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3080,7 +1820,7 @@ void POA_CORBA::Container::create_struct_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_struct",
+          "create_array_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -3100,7 +1840,7 @@ void POA_CORBA::Container::create_struct_skel (
 
 }
 
-void POA_CORBA::Container::create_union_skel (
+void POA_CORBA::TypeCodeFactory::create_value_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -3108,24 +1848,24 @@ void POA_CORBA::Container::create_union_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::UnionDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   CORBA::String_var id;
   CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::IDLType_var discriminator_type;
-  CORBA::UnionMemberSeq members;
+  CORBA::ValueModifier type_modifier;
+  CORBA::TypeCode_var concrete_base;
+  IR::ValueMemberSeq members;
   if (!(
     (_tao_in >> id.out ()) &&
     (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> discriminator_type.out ()) &&
+    (_tao_in >> type_modifier) &&
+    (_tao_in >> concrete_base.out ()) &&
     (_tao_in >> members)
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -3147,7 +1887,7 @@ void POA_CORBA::Container::create_union_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_union",
+          "create_value_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3156,23 +1896,23 @@ void POA_CORBA::Container::create_union_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_union (
+      _tao_retval = _tao_impl->create_value_tc (
         id.in (),
         name.in (),
-        version.in (),
-        discriminator_type.in (),
+        type_modifier,
+        concrete_base.in (),
         members,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_union",
+          "create_value_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3186,7 +1926,7 @@ void POA_CORBA::Container::create_union_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_union",
+          "create_value_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -3206,7 +1946,7 @@ void POA_CORBA::Container::create_union_skel (
 
 }
 
-void POA_CORBA::Container::create_enum_skel (
+void POA_CORBA::TypeCodeFactory::create_value_box_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -3214,22 +1954,20 @@ void POA_CORBA::Container::create_enum_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::EnumDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   CORBA::String_var id;
   CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::EnumMemberSeq members;
+  CORBA::TypeCode_var boxed_type;
   if (!(
     (_tao_in >> id.out ()) &&
     (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> members)
+    (_tao_in >> boxed_type.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -3251,7 +1989,7 @@ void POA_CORBA::Container::create_enum_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_enum",
+          "create_value_box_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3260,22 +1998,21 @@ void POA_CORBA::Container::create_enum_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_enum (
+      _tao_retval = _tao_impl->create_value_box_tc (
         id.in (),
         name.in (),
-        version.in (),
-        members,
+        boxed_type.in (),
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_enum",
+          "create_value_box_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3289,7 +2026,7 @@ void POA_CORBA::Container::create_enum_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_enum",
+          "create_value_box_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -3309,7 +2046,7 @@ void POA_CORBA::Container::create_enum_skel (
 
 }
 
-void POA_CORBA::Container::create_alias_skel (
+void POA_CORBA::TypeCodeFactory::create_native_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -3317,22 +2054,18 @@ void POA_CORBA::Container::create_alias_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::AliasDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   CORBA::String_var id;
   CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::IDLType_var original_type;
   if (!(
     (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> original_type.out ())
+    (_tao_in >> name.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -3354,7 +2087,7 @@ void POA_CORBA::Container::create_alias_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_alias",
+          "create_native_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3363,22 +2096,20 @@ void POA_CORBA::Container::create_alias_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_alias (
+      _tao_retval = _tao_impl->create_native_tc (
         id.in (),
         name.in (),
-        version.in (),
-        original_type.in (),
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_alias",
+          "create_native_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3392,7 +2123,7 @@ void POA_CORBA::Container::create_alias_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_alias",
+          "create_native_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -3412,7 +2143,7 @@ void POA_CORBA::Container::create_alias_skel (
 
 }
 
-void POA_CORBA::Container::create_interface_skel (
+void POA_CORBA::TypeCodeFactory::create_recursive_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -3420,22 +2151,16 @@ void POA_CORBA::Container::create_interface_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::InterfaceDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   CORBA::String_var id;
-  CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::InterfaceDefSeq base_interfaces;
   if (!(
-    (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> base_interfaces)
+    (_tao_in >> id.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -3457,7 +2182,7 @@ void POA_CORBA::Container::create_interface_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_interface",
+          "create_recursive_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3466,22 +2191,19 @@ void POA_CORBA::Container::create_interface_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_interface (
+      _tao_retval = _tao_impl->create_recursive_tc (
         id.in (),
-        name.in (),
-        version.in (),
-        base_interfaces,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_interface",
+          "create_recursive_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3495,7 +2217,7 @@ void POA_CORBA::Container::create_interface_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_interface",
+          "create_recursive_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -3515,7 +2237,7 @@ void POA_CORBA::Container::create_interface_skel (
 
 }
 
-void POA_CORBA::Container::create_value_skel (
+void POA_CORBA::TypeCodeFactory::create_abstract_interface_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -3523,34 +2245,18 @@ void POA_CORBA::Container::create_value_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::ValueDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   CORBA::String_var id;
   CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::Boolean is_custom;
-  CORBA::Boolean is_abstract;
-  CORBA::ValueDef_var base_value;
-  CORBA::Boolean is_truncatable;
-  CORBA::ValueDefSeq abstract_base_values;
-  CORBA::InterfaceDef_var supported_interface;
-  CORBA::InitializerSeq initializers;
   if (!(
     (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> CORBA::Any::to_boolean (is_custom)) &&
-    (_tao_in >> CORBA::Any::to_boolean (is_abstract)) &&
-    (_tao_in >> base_value.out ()) &&
-    (_tao_in >> CORBA::Any::to_boolean (is_truncatable)) &&
-    (_tao_in >> abstract_base_values) &&
-    (_tao_in >> supported_interface.out ()) &&
-    (_tao_in >> initializers)
+    (_tao_in >> name.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -3572,7 +2278,7 @@ void POA_CORBA::Container::create_value_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_value",
+          "create_abstract_interface_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3581,28 +2287,20 @@ void POA_CORBA::Container::create_value_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_value (
+      _tao_retval = _tao_impl->create_abstract_interface_tc (
         id.in (),
         name.in (),
-        version.in (),
-        is_custom,
-        is_abstract,
-        base_value.in (),
-        is_truncatable,
-        abstract_base_values,
-        supported_interface.in (),
-        initializers,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_value",
+          "create_abstract_interface_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3616,7 +2314,7 @@ void POA_CORBA::Container::create_value_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_value",
+          "create_abstract_interface_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -3636,7 +2334,7 @@ void POA_CORBA::Container::create_value_skel (
 
 }
 
-void POA_CORBA::Container::create_value_box_skel (
+void POA_CORBA::TypeCodeFactory::create_component_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -3644,22 +2342,18 @@ void POA_CORBA::Container::create_value_box_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::ValueBoxDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   CORBA::String_var id;
   CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::IDLType_var original_type_def;
   if (!(
     (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> original_type_def.out ())
+    (_tao_in >> name.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -3681,7 +2375,7 @@ void POA_CORBA::Container::create_value_box_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_value_box",
+          "create_component_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3690,22 +2384,20 @@ void POA_CORBA::Container::create_value_box_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_value_box (
+      _tao_retval = _tao_impl->create_component_tc (
         id.in (),
         name.in (),
-        version.in (),
-        original_type_def.in (),
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_value_box",
+          "create_component_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3719,7 +2411,7 @@ void POA_CORBA::Container::create_value_box_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_value_box",
+          "create_component_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -3739,7 +2431,7 @@ void POA_CORBA::Container::create_value_box_skel (
 
 }
 
-void POA_CORBA::Container::create_exception_skel (
+void POA_CORBA::TypeCodeFactory::create_home_tc_skel (
     CORBA::ServerRequest &_tao_server_request,
     void *_tao_object_reference, 
     void * /* context */, 
@@ -3747,22 +2439,18 @@ void POA_CORBA::Container::create_exception_skel (
 )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *)_tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *)_tao_object_reference;
 
-  CORBA::ExceptionDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   CORBA::String_var id;
   CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::StructMemberSeq members;
   if (!(
     (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> members)
+    (_tao_in >> name.out ())
   ))
     ACE_THROW (CORBA::MARSHAL () );
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   TAO_ServerRequestInterceptor_Adapter
     _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
   ACE_CHECK;
@@ -3784,7 +2472,7 @@ void POA_CORBA::Container::create_exception_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_exception",
+          "create_home_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3793,22 +2481,20 @@ void POA_CORBA::Container::create_exception_skel (
       TAO_INTERCEPTOR_CHECK;
 #endif /* TAO_HAS_INTERCEPTORS */
 
-      _tao_retval = _tao_impl->create_exception (
+      _tao_retval = _tao_impl->create_home_tc (
         id.in (),
         name.in (),
-        version.in (),
-        members,
         ACE_TRY_ENV
       );
 
       TAO_INTERCEPTOR_CHECK;
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
       _tao_vfr.postinvoke (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_exception",
+          "create_home_tc",
           _tao_server_request.service_info (),
           _tao_interceptor_args.inout (),
           _tao_cookies,
@@ -3822,7 +2508,7 @@ void POA_CORBA::Container::create_exception_skel (
           _tao_server_request.request_id (),
           1,
           _tao_objref.in (),
-          "create_exception",
+          "create_home_tc",
           _tao_cookies,
           ACE_TRY_ENV
         );
@@ -3842,7 +2528,7 @@ void POA_CORBA::Container::create_exception_skel (
 
 }
 
-void POA_CORBA::Container::_is_a_skel (
+void POA_CORBA::TypeCodeFactory::_is_a_skel (
     CORBA::ServerRequest &_tao_server_request, 
     void * _tao_object_reference,
     void * /* context */,
@@ -3850,7 +2536,7 @@ void POA_CORBA::Container::_is_a_skel (
   )
 {
   TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *) _tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *) _tao_object_reference;
   CORBA::Boolean _tao_retval = 0;
   CORBA::String_var value;
   if (!((_tao_in >> value.out ())))
@@ -3866,14 +2552,14 @@ void POA_CORBA::Container::_is_a_skel (
     ACE_THROW (CORBA::MARSHAL ());
 }
 
-void POA_CORBA::Container::_non_existent_skel (
+void POA_CORBA::TypeCodeFactory::_non_existent_skel (
     CORBA::ServerRequest &_tao_server_request, 
     void * _tao_object_reference,
     void * /* context */,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
-  POA_CORBA::Container *_tao_impl = (POA_CORBA::Container *) _tao_object_reference;
+  POA_CORBA::TypeCodeFactory *_tao_impl = (POA_CORBA::TypeCodeFactory *) _tao_object_reference;
   CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
   ACE_CHECK;
   
@@ -3884,34 +2570,31 @@ void POA_CORBA::Container::_non_existent_skel (
     ACE_THROW (CORBA::MARSHAL ());
 }
 
-CORBA::Boolean POA_CORBA::Container::_is_a (
+CORBA::Boolean POA_CORBA::TypeCodeFactory::_is_a (
     const char* value,
     CORBA::Environment &ACE_TRY_ENV
   )
 {
   if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
+    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypeCodeFactory:1.0")) ||
     (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
       return 1;
     else
       return 0;
 }
 
-void* POA_CORBA::Container::_downcast (
+void* POA_CORBA::TypeCodeFactory::_downcast (
     const char* logical_type_id
   )
 {
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Container:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Container_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
+if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/TypeCodeFactory:1.0") == 0)
+    return ACE_static_cast (POA_CORBA::TypeCodeFactory_ptr, this);
     if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
     return ACE_static_cast(PortableServer::Servant, this);
   return 0;
 }
 
-void POA_CORBA::Container::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
+void POA_CORBA::TypeCodeFactory::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
 {
   TAO_Skeleton skel; // pointer to skeleton for operation
   const char *opname = req.operation (); // retrieve operation name
@@ -3925,13 +2608,13 @@ void POA_CORBA::Container::_dispatch (CORBA::ServerRequest &req, void *context,
     skel (req, this, context, ACE_TRY_ENV);
 }
 
-const char* POA_CORBA::Container::_interface_repository_id (void) const
+const char* POA_CORBA::TypeCodeFactory::_interface_repository_id (void) const
 {
-  return "IDL:omg.org/CORBA/Container:1.0";
+  return "IDL:omg.org/CORBA/TypeCodeFactory:1.0";
 }
 
-CORBA::Container*
-POA_CORBA::Container::_this (CORBA_Environment &ACE_TRY_ENV)
+CORBA::TypeCodeFactory*
+POA_CORBA::TypeCodeFactory::_this (CORBA_Environment &ACE_TRY_ENV)
 {
   TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
   ACE_CHECK_RETURN (0);
@@ -3940,10 +2623,10 @@ POA_CORBA::Container::_this (CORBA_Environment &ACE_TRY_ENV)
       {
       case TAO_ORB_Core::THRU_POA:
         {
-          ::CORBA::Container_ptr retval = 0;
+          ::CORBA::TypeCodeFactory_ptr retval = 0;
           ACE_NEW_RETURN (
               retval,
-              POA_CORBA::_tao_thru_poa_collocated_Container (stub),
+              POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory (stub),
               0
             );
           return retval;
@@ -3959,19 +2642,18 @@ POA_CORBA::Container::_this (CORBA_Environment &ACE_TRY_ENV)
       CORBA::Object_ptr tmp = CORBA::Object::_nil ();
       ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
       CORBA::Object_var obj = tmp;
-      return ::CORBA::Container::_unchecked_narrow (obj.in ());
+      return ::CORBA::TypeCodeFactory::_unchecked_narrow (obj.in ());
     }
 }
 
-POA_CORBA::_tao_thru_poa_collocated_Container::_tao_thru_poa_collocated_Container (
+POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::_tao_thru_poa_collocated_TypeCodeFactory (
   TAO_Stub *stub
 )
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
+  :  CORBA_Object (stub, 0, 1)
 {
 }
 
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_Container::_is_a(
+CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::_is_a(
     const CORBA::Char *logical_type_id,
     CORBA_Environment &ACE_TRY_ENV
   )
@@ -3987,15 +2669,15 @@ CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_Container::_is_a(
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
     )->_is_a (logical_type_id, ACE_TRY_ENV);
 }
 
 
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_Container::_non_existent(
+CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::_non_existent(
     CORBA_Environment &ACE_TRY_ENV
   )
 
@@ -4010,293 +2692,79 @@ CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_Container::_non_existent(
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
     )->_non_existent (ACE_TRY_ENV);
 }
 
 
-CORBA::Contained_ptr POA_CORBA::_tao_thru_poa_collocated_Container::lookup  (
-    const char * search_name,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Contained_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "lookup",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
-        )
-    )->lookup (
-      search_name,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::ContainedSeq * POA_CORBA::_tao_thru_poa_collocated_Container::contents  (
-    CORBA::DefinitionKind limit_type,
-    CORBA::Boolean exclude_inherited,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ContainedSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "contents",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
-        )
-    )->contents (
-      limit_type,
-      exclude_inherited,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::ContainedSeq * POA_CORBA::_tao_thru_poa_collocated_Container::lookup_name  (
-    const char * search_name,
-    CORBA::Long levels_to_search,
-    CORBA::DefinitionKind limit_type,
-    CORBA::Boolean exclude_inherited,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ContainedSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "lookup_name",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
-        )
-    )->lookup_name (
-      search_name,
-      levels_to_search,
-      limit_type,
-      exclude_inherited,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::Container::DescriptionSeq * POA_CORBA::_tao_thru_poa_collocated_Container::describe_contents  (
-    CORBA::DefinitionKind limit_type,
-    CORBA::Boolean exclude_inherited,
-    CORBA::Long max_returned_objs,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Container::DescriptionSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "describe_contents",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
-        )
-    )->describe_contents (
-      limit_type,
-      exclude_inherited,
-      max_returned_objs,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::ModuleDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_module  (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ModuleDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "create_module",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
-        )
-    )->create_module (
-      id,
-      name,
-      version,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::ConstantDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_constant  (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::IDLType_ptr type,
-    const CORBA::Any & value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ConstantDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "create_constant",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
-        )
-    )->create_constant (
-      id,
-      name,
-      version,
-      type,
-      value,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::StructDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_struct  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_struct_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    const CORBA::StructMemberSeq & members,
+    const IR::StructMemberSeq & members,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::StructDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_struct",
+      "create_struct_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_struct (
+    )->create_struct_tc (
       id,
       name,
-      version,
       members,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::UnionDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_union  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_union_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    CORBA::IDLType_ptr discriminator_type,
-    const CORBA::UnionMemberSeq & members,
+    CORBA::TypeCode_ptr discriminator_type,
+    const IR::UnionMemberSeq & members,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::UnionDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_union",
+      "create_union_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_union (
+    )->create_union_tc (
       id,
       name,
-      version,
       discriminator_type,
       members,
       ACE_TRY_ENV
@@ -4304,1799 +2772,145 @@ CORBA::UnionDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_union
 
 }
 
-CORBA::EnumDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_enum  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_enum_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    const CORBA::EnumMemberSeq & members,
+    const IR::EnumMemberSeq & members,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::EnumDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_enum",
+      "create_enum_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_enum (
+    )->create_enum_tc (
       id,
       name,
-      version,
       members,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::AliasDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_alias  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_alias_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    CORBA::IDLType_ptr original_type,
+    CORBA::TypeCode_ptr original_type,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::AliasDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_alias",
+      "create_alias_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_alias (
+    )->create_alias_tc (
       id,
       name,
-      version,
       original_type,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::InterfaceDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_interface  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_exception_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    const CORBA::InterfaceDefSeq & base_interfaces,
+    const IR::StructMemberSeq & members,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::InterfaceDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "create_interface",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
-        )
-    )->create_interface (
-      id,
-      name,
-      version,
-      base_interfaces,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::ValueDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_value  (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::Boolean is_custom,
-    CORBA::Boolean is_abstract,
-    CORBA::ValueDef_ptr base_value,
-    CORBA::Boolean is_truncatable,
-    const CORBA::ValueDefSeq & abstract_base_values,
-    CORBA::InterfaceDef_ptr supported_interface,
-    const CORBA::InitializerSeq & initializers,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ValueDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "create_value",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
-        )
-    )->create_value (
-      id,
-      name,
-      version,
-      is_custom,
-      is_abstract,
-      base_value,
-      is_truncatable,
-      abstract_base_values,
-      supported_interface,
-      initializers,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::ValueBoxDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_value_box  (
-    const char * id,
-    const char * name,
-    const char * version,
-    CORBA::IDLType_ptr original_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ValueBoxDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_value_box",
+      "create_exception_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_value_box (
+    )->create_exception_tc (
       id,
       name,
-      version,
-      original_type_def,
+      members,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::ExceptionDef_ptr POA_CORBA::_tao_thru_poa_collocated_Container::create_exception  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_interface_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    const CORBA::StructMemberSeq & members,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::ExceptionDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_exception",
+      "create_interface_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Container_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Container:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_exception (
+    )->create_interface_tc (
       id,
       name,
-      version,
-      members,
       ACE_TRY_ENV
     );
 
 }
 
-
-
-class TAO_CORBA_IDLType_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_IDLType_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_IDLType_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19,  0,  0, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19,  5, 19, 19, 19, 19,  0, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19,
-#else
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19,  0, 19,  0, 19, 19,
-      0,  0, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19,  5, 19, 19, 19,
-     19,  0, 19, 19, 19, 19, 19, 19,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_IDLType_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 5,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 13,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 18,
-      HASH_VALUE_RANGE = 14,
-      DUPLICATES = 0
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::IDLType::_is_a_skel},
-      {"",0},
-      {"destroy", 	&POA_CORBA::IDLType::destroy_skel},
-      {"",0},
-      {"_get_type", 	&POA_CORBA::IDLType::_get_type_skel},
-      {"",0},{"",0},{"",0},
-      {"_get_def_kind", 	&POA_CORBA::IDLType::_get_def_kind_skel},
-      {"",0},{"",0},{"",0},{"",0},
-      {"_non_existent",  &POA_CORBA::IDLType::_non_existent_skel},
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          const char *s = wordlist[key].opname_;
-
-          if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-            return &wordlist[key];
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_IDLType_Perfect_Hash_OpTable tao_CORBA_IDLType_optable;
-
-CORBA::IDLType_ptr _TAO_collocation_POA_CORBA_IDLType_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::IDLType_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_IDLType (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_IDLType_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_IDLType_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_IDLType_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_IDLType_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_IDLType_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_IDLType_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::IDLType::IDLType (void)
-{
-  this->optable_ = &tao_CORBA_IDLType_optable;
-}
-
-// copy ctor
-POA_CORBA::IDLType::IDLType (const IDLType& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::IDLType::~IDLType (void)
-{
-}
-
-void POA_CORBA::IDLType::_get_type_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::IDLType *_tao_impl = (POA_CORBA::IDLType *)_tao_object_reference;
-
-  CORBA::TypeCode_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->type (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::IDLType::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::IDLType *_tao_impl = (POA_CORBA::IDLType *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::IDLType::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::IDLType *_tao_impl = (POA_CORBA::IDLType *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::IDLType::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::IDLType::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::IDLType::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::IDLType::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/IDLType:1.0";
-}
-
-CORBA::IDLType*
-POA_CORBA::IDLType::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::IDLType_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_IDLType (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::IDLType::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_IDLType::_tao_thru_poa_collocated_IDLType (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_IDLType::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::IDLType_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/IDLType:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_IDLType::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::IDLType_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/IDLType:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_IDLType::type  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::TypeCode_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "type",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::IDLType_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/IDLType:1.0"
-        )
-    )->type (
-      ACE_TRY_ENV
-    );
-
-}
-
-
-
-class TAO_CORBA_Repository_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_Repository_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_Repository_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 25,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 10,
-     66,  0, 23, 10, 66,  5, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66,  0,  0, 15,
-     66,  0, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 25,  0, 66, 66, 66,  0,  0, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66,
-#else
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 66, 66, 66, 66, 66,
-     66, 66, 66, 66, 66, 25, 66, 10, 66,  0,
-     23, 10, 66,  5, 66, 66, 66, 66,  0,  0,
-     15, 66,  0, 66, 66, 25,  0, 66, 66, 66,
-      0,  0, 66, 66, 66, 66, 66, 66,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_Repository_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 25,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 17,
-      MIN_HASH_VALUE = 6,
-      MAX_HASH_VALUE = 65,
-      HASH_VALUE_RANGE = 60,
-      DUPLICATES = 0
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},{"",0},
-      {"lookup", 	&POA_CORBA::Repository::lookup_skel},
-      {"",0},{"",0},{"",0},{"",0},
-      {"create_enum", 	&POA_CORBA::Repository::create_enum_skel},
-      {"create_array", 	&POA_CORBA::Repository::create_array_skel},
-      {"create_struct", 	&POA_CORBA::Repository::create_struct_skel},
-      {"",0},
-      {"create_constant", 	&POA_CORBA::Repository::create_constant_skel},
-      {"create_value_box", 	&POA_CORBA::Repository::create_value_box_skel},
-      {"",0},
-      {"create_string", 	&POA_CORBA::Repository::create_string_skel},
-      {"create_wstring", 	&POA_CORBA::Repository::create_wstring_skel},
-      {"",0},
-      {"lookup_name", 	&POA_CORBA::Repository::lookup_name_skel},
-      {"create_value", 	&POA_CORBA::Repository::create_value_skel},
-      {"create_module", 	&POA_CORBA::Repository::create_module_skel},
-      {"",0},
-      {"create_sequence", 	&POA_CORBA::Repository::create_sequence_skel},
-      {"create_interface", 	&POA_CORBA::Repository::create_interface_skel},
-      {"create_union", 	&POA_CORBA::Repository::create_union_skel},
-      {"get_primitive", 	&POA_CORBA::Repository::get_primitive_skel},
-      {"",0},
-      {"destroy", 	&POA_CORBA::Repository::destroy_skel},
-      {"create_exception", 	&POA_CORBA::Repository::create_exception_skel},
-      {"lookup_id", 	&POA_CORBA::Repository::lookup_id_skel},
-      {"contents", 	&POA_CORBA::Repository::contents_skel},
-      {"",0},
-      {"create_fixed", 	&POA_CORBA::Repository::create_fixed_skel},
-      {"",0},
-      {"create_alias", 	&POA_CORBA::Repository::create_alias_skel},
-      {"_non_existent",  &POA_CORBA::Repository::_non_existent_skel},
-      {"",0},
-      {"_is_a",  &POA_CORBA::Repository::_is_a_skel},
-      {"",0},{"",0},{"",0},{"",0},{"",0},{"",0},{"",0},{"",0},{"",0},
-      {"",0},{"",0},{"",0},{"",0},{"",0},{"",0},{"",0},{"",0},{"",0},
-      {"",0},{"",0},
-      {"_get_def_kind", 	&POA_CORBA::Repository::_get_def_kind_skel},
-      {"",0},{"",0},{"",0},
-      {"describe_contents", 	&POA_CORBA::Repository::describe_contents_skel},
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          const char *s = wordlist[key].opname_;
-
-          if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-            return &wordlist[key];
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_Repository_Perfect_Hash_OpTable tao_CORBA_Repository_optable;
-
-CORBA::Repository_ptr _TAO_collocation_POA_CORBA_Repository_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::Repository_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_Repository (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_Repository_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_Repository_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_Repository_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_Repository_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_Repository_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_Repository_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::Repository::Repository (void)
-{
-  this->optable_ = &tao_CORBA_Repository_optable;
-}
-
-// copy ctor
-POA_CORBA::Repository::Repository (const Repository& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Container) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::Repository::~Repository (void)
-{
-}
-
-void POA_CORBA::Repository::lookup_id_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Repository *_tao_impl = (POA_CORBA::Repository *)_tao_object_reference;
-
-  CORBA::Contained_var _tao_retval;
-  CORBA::String_var search_id;
-  if (!(
-    (_tao_in >> search_id.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "lookup_id",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->lookup_id (
-        search_id.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "lookup_id",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "lookup_id",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::Repository::get_primitive_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Repository *_tao_impl = (POA_CORBA::Repository *)_tao_object_reference;
-
-  CORBA::PrimitiveDef_var _tao_retval;
-  CORBA::PrimitiveKind kind;
-  if (!(
-    (_tao_in >> kind)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "get_primitive",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->get_primitive (
-        kind,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "get_primitive",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "get_primitive",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::Repository::create_string_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Repository *_tao_impl = (POA_CORBA::Repository *)_tao_object_reference;
-
-  CORBA::StringDef_var _tao_retval;
-  CORBA::ULong bound;
-  if (!(
-    (_tao_in >> bound)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_string",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_string (
-        bound,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_string",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_string",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::Repository::create_wstring_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Repository *_tao_impl = (POA_CORBA::Repository *)_tao_object_reference;
-
-  CORBA::WstringDef_var _tao_retval;
-  CORBA::ULong bound;
-  if (!(
-    (_tao_in >> bound)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_wstring",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_wstring (
-        bound,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_wstring",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_wstring",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::Repository::create_sequence_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Repository *_tao_impl = (POA_CORBA::Repository *)_tao_object_reference;
-
-  CORBA::SequenceDef_var _tao_retval;
-  CORBA::ULong bound;
-  CORBA::IDLType_var element_type;
-  if (!(
-    (_tao_in >> bound) &&
-    (_tao_in >> element_type.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_sequence",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_sequence (
-        bound,
-        element_type.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_sequence",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_sequence",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::Repository::create_array_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Repository *_tao_impl = (POA_CORBA::Repository *)_tao_object_reference;
-
-  CORBA::ArrayDef_var _tao_retval;
-  CORBA::ULong length;
-  CORBA::IDLType_var element_type;
-  if (!(
-    (_tao_in >> length) &&
-    (_tao_in >> element_type.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_array",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_array (
-        length,
-        element_type.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_array",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_array",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::Repository::create_fixed_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Repository *_tao_impl = (POA_CORBA::Repository *)_tao_object_reference;
-
-  CORBA::FixedDef_var _tao_retval;
-  CORBA::UShort digits;
-  CORBA::Short scale;
-  if (!(
-    (_tao_in >> digits) &&
-    (_tao_in >> scale)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_fixed",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_fixed (
-        digits,
-        scale,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_fixed",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_fixed",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::Repository::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::Repository *_tao_impl = (POA_CORBA::Repository *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::Repository::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::Repository *_tao_impl = (POA_CORBA::Repository *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::Repository::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Repository:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::Repository::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Repository:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Repository_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Container:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Container_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::Repository::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::Repository::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/Repository:1.0";
-}
-
-CORBA::Repository*
-POA_CORBA::Repository::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::Repository_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_Repository (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::Repository::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_Repository::_tao_thru_poa_collocated_Repository (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Container) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_Repository::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Repository_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Repository:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_Repository::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Repository_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Repository:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::Contained_ptr POA_CORBA::_tao_thru_poa_collocated_Repository::lookup_id  (
-    const char * search_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Contained_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "lookup_id",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Repository_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Repository:1.0"
-        )
-    )->lookup_id (
-      search_id,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::PrimitiveDef_ptr POA_CORBA::_tao_thru_poa_collocated_Repository::get_primitive  (
-    CORBA::PrimitiveKind kind,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::PrimitiveDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "get_primitive",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Repository_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Repository:1.0"
-        )
-    )->get_primitive (
-      kind,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::StringDef_ptr POA_CORBA::_tao_thru_poa_collocated_Repository::create_string  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_string_tc  (
     CORBA::ULong bound,
     CORBA::Environment &ACE_TRY_ENV
   )
@@ -6104,8105 +2918,96 @@ CORBA::StringDef_ptr POA_CORBA::_tao_thru_poa_collocated_Repository::create_stri
     CORBA::SystemException
   ))
 {
-  CORBA::StringDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "create_string",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Repository_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Repository:1.0"
-        )
-    )->create_string (
-      bound,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::WstringDef_ptr POA_CORBA::_tao_thru_poa_collocated_Repository::create_wstring  (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::WstringDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_wstring",
+      "create_string_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Repository_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Repository:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_wstring (
+    )->create_string_tc (
       bound,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::SequenceDef_ptr POA_CORBA::_tao_thru_poa_collocated_Repository::create_sequence  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_wstring_tc  (
     CORBA::ULong bound,
-    CORBA::IDLType_ptr element_type,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::SequenceDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_sequence",
+      "create_wstring_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::Repository_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Repository:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_sequence (
+    )->create_wstring_tc (
       bound,
-      element_type,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::ArrayDef_ptr POA_CORBA::_tao_thru_poa_collocated_Repository::create_array  (
-    CORBA::ULong length,
-    CORBA::IDLType_ptr element_type,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ArrayDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "create_array",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Repository_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Repository:1.0"
-        )
-    )->create_array (
-      length,
-      element_type,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::FixedDef_ptr POA_CORBA::_tao_thru_poa_collocated_Repository::create_fixed  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_fixed_tc  (
     CORBA::UShort digits,
-    CORBA::Short scale,
+    CORBA::UShort scale,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::FixedDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "create_fixed",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::Repository_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/Repository:1.0"
-        )
-    )->create_fixed (
-      digits,
-      scale,
-      ACE_TRY_ENV
-    );
-
-}
-
-
-
-class TAO_CORBA_ModuleDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_ModuleDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_ModuleDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61,  0,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61,  0,
-     61, 20,  3,  0, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 10, 15,  5,
-     61, 10, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 15, 25, 61, 61, 61, 15,  5, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61,
-#else
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
-     61, 61, 61, 61, 61,  0, 61,  0, 61, 20,
-      3,  0, 61, 61, 61, 61, 61, 61, 10, 15,
-      5, 61, 10, 61, 61, 15, 25, 61, 61, 61,
-     15,  5, 61, 61, 61, 61, 61, 61,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_ModuleDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 29,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 60,
-      HASH_VALUE_RANGE = 56,
-      DUPLICATES = 4
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::ModuleDef::_is_a_skel},
-      {"_get_name", 	&POA_CORBA::ModuleDef::_get_name_skel},
-      {"_set_name", 	&POA_CORBA::ModuleDef::_set_name_skel},
-      {"_get_id", 	&POA_CORBA::ModuleDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::ModuleDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::ModuleDef::describe_skel},
-      {"destroy", 	&POA_CORBA::ModuleDef::destroy_skel},
-      {"_get_def_kind", 	&POA_CORBA::ModuleDef::_get_def_kind_skel},
-      {"_get_version", 	&POA_CORBA::ModuleDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::ModuleDef::_set_version_skel},
-      {"_get_absolute_name", 	&POA_CORBA::ModuleDef::_get_absolute_name_skel},
-      {"move", 	&POA_CORBA::ModuleDef::move_skel},
-      {"_get_defined_in", 	&POA_CORBA::ModuleDef::_get_defined_in_skel},
-      {"lookup_name", 	&POA_CORBA::ModuleDef::lookup_name_skel},
-      {"lookup", 	&POA_CORBA::ModuleDef::lookup_skel},
-      {"_get_containing_repository", 	&POA_CORBA::ModuleDef::_get_containing_repository_skel},
-      {"create_value", 	&POA_CORBA::ModuleDef::create_value_skel},
-      {"create_module", 	&POA_CORBA::ModuleDef::create_module_skel},
-      {"describe_contents", 	&POA_CORBA::ModuleDef::describe_contents_skel},
-      {"create_interface", 	&POA_CORBA::ModuleDef::create_interface_skel},
-      {"create_union", 	&POA_CORBA::ModuleDef::create_union_skel},
-      {"_non_existent",  &POA_CORBA::ModuleDef::_non_existent_skel},
-      {"create_exception", 	&POA_CORBA::ModuleDef::create_exception_skel},
-      {"contents", 	&POA_CORBA::ModuleDef::contents_skel},
-      {"create_enum", 	&POA_CORBA::ModuleDef::create_enum_skel},
-      {"create_alias", 	&POA_CORBA::ModuleDef::create_alias_skel},
-      {"create_value_box", 	&POA_CORBA::ModuleDef::create_value_box_skel},
-      {"create_struct", 	&POA_CORBA::ModuleDef::create_struct_skel},
-      {"create_constant", 	&POA_CORBA::ModuleDef::create_constant_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -6,  -2,   5,  -1,  -8,  -2, -66, -63,  10,  -1, -13, 
-       -2,  11,  12, -64,  15,  16,  17,  18,  -1,  -1,  -1,  -1,  19,  -1, 
-       -1,  -1,  -1,  20,  21,  22,  -1,  23,  24,  25,  26,  -1,  -1,  27, 
-       -1,  28,  -1,  -1,  29,  30,  -1,  -1,  -1,  31,  -1,  -1,  -1,  -1, 
-       -1,  -1,  32,  -1,  33, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_ModuleDef_Perfect_Hash_OpTable tao_CORBA_ModuleDef_optable;
-
-CORBA::ModuleDef_ptr _TAO_collocation_POA_CORBA_ModuleDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::ModuleDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_ModuleDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_ModuleDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_ModuleDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_ModuleDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_ModuleDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_ModuleDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_ModuleDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::ModuleDef::ModuleDef (void)
-{
-  this->optable_ = &tao_CORBA_ModuleDef_optable;
-}
-
-// copy ctor
-POA_CORBA::ModuleDef::ModuleDef (const ModuleDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Container) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::ModuleDef::~ModuleDef (void)
-{
-}
-
-void POA_CORBA::ModuleDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ModuleDef *_tao_impl = (POA_CORBA::ModuleDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::ModuleDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::ModuleDef *_tao_impl = (POA_CORBA::ModuleDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::ModuleDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ModuleDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::ModuleDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/ModuleDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::ModuleDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Container:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Container_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::ModuleDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::ModuleDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/ModuleDef:1.0";
-}
-
-CORBA::ModuleDef*
-POA_CORBA::ModuleDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::ModuleDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_ModuleDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::ModuleDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_ModuleDef::_tao_thru_poa_collocated_ModuleDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Container) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ModuleDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ModuleDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ModuleDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ModuleDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ModuleDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ModuleDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-
-
-class TAO_CORBA_ConstantDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_ConstantDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_ConstantDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37,  0,  0, 10, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37,  0,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 15, 37, 37, 37, 37, 10, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37,
-#else
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37,  0, 37,  0, 37, 37,
-      0,  0, 10, 37, 37, 37, 37, 37, 37,  0,
-      0, 37, 37, 37, 37, 37, 15, 37, 37, 37,
-     37, 10, 37, 37, 37, 37, 37, 37,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_ConstantDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 20,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 36,
-      HASH_VALUE_RANGE = 33,
-      DUPLICATES = 7
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::ConstantDef::move_skel},
-      {"_is_a",  &POA_CORBA::ConstantDef::_is_a_skel},
-      {"_get_id", 	&POA_CORBA::ConstantDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::ConstantDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::ConstantDef::describe_skel},
-      {"_get_type", 	&POA_CORBA::ConstantDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::ConstantDef::_set_name_skel},
-      {"_get_name", 	&POA_CORBA::ConstantDef::_get_name_skel},
-      {"_get_value", 	&POA_CORBA::ConstantDef::_get_value_skel},
-      {"_set_value", 	&POA_CORBA::ConstantDef::_set_value_skel},
-      {"_get_version", 	&POA_CORBA::ConstantDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::ConstantDef::_set_version_skel},
-      {"_get_def_kind", 	&POA_CORBA::ConstantDef::_get_def_kind_skel},
-      {"_get_defined_in", 	&POA_CORBA::ConstantDef::_get_defined_in_skel},
-      {"destroy", 	&POA_CORBA::ConstantDef::destroy_skel},
-      {"_get_absolute_name", 	&POA_CORBA::ConstantDef::_get_absolute_name_skel},
-      {"_get_type_def", 	&POA_CORBA::ConstantDef::_get_type_def_skel},
-      {"_set_type_def", 	&POA_CORBA::ConstantDef::_set_type_def_skel},
-      {"_non_existent",  &POA_CORBA::ConstantDef::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::ConstantDef::_get_containing_repository_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-      -12,  -2, -14,  -2,   4,   5,  -1,  53,   8,  46, -46,  -1, -46,  16, 
-       -1,  17,  -1,  18,  19,  -9,  -3, -20,  -2, -38,  -6,  -2,  -1,  -1, 
-       22,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  23, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_ConstantDef_Perfect_Hash_OpTable tao_CORBA_ConstantDef_optable;
-
-CORBA::ConstantDef_ptr _TAO_collocation_POA_CORBA_ConstantDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::ConstantDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_ConstantDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_ConstantDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_ConstantDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_ConstantDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_ConstantDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_ConstantDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_ConstantDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::ConstantDef::ConstantDef (void)
-{
-  this->optable_ = &tao_CORBA_ConstantDef_optable;
-}
-
-// copy ctor
-POA_CORBA::ConstantDef::ConstantDef (const ConstantDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::ConstantDef::~ConstantDef (void)
-{
-}
-
-void POA_CORBA::ConstantDef::_get_type_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ConstantDef *_tao_impl = (POA_CORBA::ConstantDef *)_tao_object_reference;
-
   CORBA::TypeCode_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->type (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ConstantDef::_get_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ConstantDef *_tao_impl = (POA_CORBA::ConstantDef *)_tao_object_reference;
-
-  CORBA::IDLType_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->type_def (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ConstantDef::_set_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ConstantDef *_tao_impl = (POA_CORBA::ConstantDef *)_tao_object_reference;
-
-  CORBA::IDLType_var type_def;
-  if (!(
-    (_tao_in >> type_def.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->type_def (
-        type_def.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ConstantDef::_get_value_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ConstantDef *_tao_impl = (POA_CORBA::ConstantDef *)_tao_object_reference;
-
-  CORBA::Any_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->value (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_value",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ConstantDef::_set_value_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ConstantDef *_tao_impl = (POA_CORBA::ConstantDef *)_tao_object_reference;
-
-  CORBA::Any value;
-  if (!(
-    (_tao_in >> value)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->value (
-        value,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_value",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ConstantDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ConstantDef *_tao_impl = (POA_CORBA::ConstantDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::ConstantDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::ConstantDef *_tao_impl = (POA_CORBA::ConstantDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::ConstantDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ConstantDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::ConstantDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/ConstantDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::ConstantDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::ConstantDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::ConstantDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/ConstantDef:1.0";
-}
-
-CORBA::ConstantDef*
-POA_CORBA::ConstantDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::ConstantDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_ConstantDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::ConstantDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_ConstantDef::_tao_thru_poa_collocated_ConstantDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ConstantDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ConstantDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ConstantDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ConstantDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ConstantDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ConstantDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_ConstantDef::type  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::TypeCode_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "type",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ConstantDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ConstantDef:1.0"
-        )
-    )->type (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::IDLType_ptr POA_CORBA::_tao_thru_poa_collocated_ConstantDef::type_def  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::IDLType_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "type_def",
+      "create_fixed_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::ConstantDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ConstantDef:1.0"
-        )
-    )->type_def (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ConstantDef::type_def  (
-    CORBA::IDLType_ptr type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ConstantDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ConstantDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->type_def (
-      type_def,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::Any * POA_CORBA::_tao_thru_poa_collocated_ConstantDef::value  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Any_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "value",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ConstantDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ConstantDef:1.0"
-        )
-    )->value (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ConstantDef::value  (
-    const CORBA::Any & value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "value",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ConstantDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ConstantDef:1.0"
-        )
-    )->value (
-      value,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_TypedefDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_TypedefDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_TypedefDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37,  0,  0, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37,  0,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 10, 37, 37, 37, 37, 10, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37,
-#else
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37,  0, 37,  0, 37, 37,
-      0,  0, 37, 37, 37, 37, 37, 37, 37,  0,
-      0, 37, 37, 37, 37, 37, 10, 37, 37, 37,
-     37, 10, 37, 37, 37, 37, 37, 37,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_TypedefDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 16,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 36,
-      HASH_VALUE_RANGE = 33,
-      DUPLICATES = 5
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::TypedefDef::move_skel},
-      {"_is_a",  &POA_CORBA::TypedefDef::_is_a_skel},
-      {"_get_id", 	&POA_CORBA::TypedefDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::TypedefDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::TypedefDef::describe_skel},
-      {"_get_name", 	&POA_CORBA::TypedefDef::_get_name_skel},
-      {"_get_type", 	&POA_CORBA::TypedefDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::TypedefDef::_set_name_skel},
-      {"_get_version", 	&POA_CORBA::TypedefDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::TypedefDef::_set_version_skel},
-      {"_get_def_kind", 	&POA_CORBA::TypedefDef::_get_def_kind_skel},
-      {"_get_defined_in", 	&POA_CORBA::TypedefDef::_get_defined_in_skel},
-      {"destroy", 	&POA_CORBA::TypedefDef::destroy_skel},
-      {"_get_absolute_name", 	&POA_CORBA::TypedefDef::_get_absolute_name_skel},
-      {"_non_existent",  &POA_CORBA::TypedefDef::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::TypedefDef::_get_containing_repository_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -6,  -2,  -9,  -3,   4,   5,  -1, -43,   8, -43, -12,  -2, -38,  14, 
-       -1,  15,  -1,  16,  17,  -1,  -1,  -1,  -1,  18,  -1,  -1,  -1,  -1, 
-       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  19, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_TypedefDef_Perfect_Hash_OpTable tao_CORBA_TypedefDef_optable;
-
-CORBA::TypedefDef_ptr _TAO_collocation_POA_CORBA_TypedefDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::TypedefDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_TypedefDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_TypedefDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_TypedefDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_TypedefDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_TypedefDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_TypedefDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_TypedefDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::TypedefDef::TypedefDef (void)
-{
-  this->optable_ = &tao_CORBA_TypedefDef_optable;
-}
-
-// copy ctor
-POA_CORBA::TypedefDef::TypedefDef (const TypedefDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::TypedefDef::~TypedefDef (void)
-{
-}
-
-void POA_CORBA::TypedefDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::TypedefDef *_tao_impl = (POA_CORBA::TypedefDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::TypedefDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::TypedefDef *_tao_impl = (POA_CORBA::TypedefDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::TypedefDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::TypedefDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/TypedefDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::TypedefDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::TypedefDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::TypedefDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/TypedefDef:1.0";
-}
-
-CORBA::TypedefDef*
-POA_CORBA::TypedefDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::TypedefDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_TypedefDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::TypedefDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_TypedefDef::_tao_thru_poa_collocated_TypedefDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_TypedefDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::TypedefDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/TypedefDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_TypedefDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::TypedefDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/TypedefDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-
-
-class TAO_CORBA_StructDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_StructDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_StructDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58,  0,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58,  0,
-     58, 20,  3,  0, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 10, 10, 10,
-     58, 10, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 25, 15, 58, 58, 58, 15,  5, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58,
-#else
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58, 58, 58, 58, 58, 58,
-     58, 58, 58, 58, 58,  0, 58,  0, 58, 20,
-      3,  0, 58, 58, 58, 58, 58, 58, 10, 10,
-     10, 58, 10, 58, 58, 25, 15, 58, 58, 58,
-     15,  5, 58, 58, 58, 58, 58, 58,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_StructDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 32,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 57,
-      HASH_VALUE_RANGE = 53,
-      DUPLICATES = 6
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::StructDef::_is_a_skel},
-      {"_get_name", 	&POA_CORBA::StructDef::_get_name_skel},
-      {"_get_type", 	&POA_CORBA::StructDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::StructDef::_set_name_skel},
-      {"_get_id", 	&POA_CORBA::StructDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::StructDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::StructDef::describe_skel},
-      {"move", 	&POA_CORBA::StructDef::move_skel},
-      {"destroy", 	&POA_CORBA::StructDef::destroy_skel},
-      {"_get_def_kind", 	&POA_CORBA::StructDef::_get_def_kind_skel},
-      {"_get_absolute_name", 	&POA_CORBA::StructDef::_get_absolute_name_skel},
-      {"lookup_name", 	&POA_CORBA::StructDef::lookup_name_skel},
-      {"_get_version", 	&POA_CORBA::StructDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::StructDef::_set_version_skel},
-      {"_get_defined_in", 	&POA_CORBA::StructDef::_get_defined_in_skel},
-      {"lookup", 	&POA_CORBA::StructDef::lookup_skel},
-      {"_non_existent",  &POA_CORBA::StructDef::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::StructDef::_get_containing_repository_skel},
-      {"create_value", 	&POA_CORBA::StructDef::create_value_skel},
-      {"create_module", 	&POA_CORBA::StructDef::create_module_skel},
-      {"create_interface", 	&POA_CORBA::StructDef::create_interface_skel},
-      {"_get_members", 	&POA_CORBA::StructDef::_get_members_skel},
-      {"_set_members", 	&POA_CORBA::StructDef::_set_members_skel},
-      {"create_enum", 	&POA_CORBA::StructDef::create_enum_skel},
-      {"create_union", 	&POA_CORBA::StructDef::create_union_skel},
-      {"describe_contents", 	&POA_CORBA::StructDef::describe_contents_skel},
-      {"create_exception", 	&POA_CORBA::StructDef::create_exception_skel},
-      {"create_struct", 	&POA_CORBA::StructDef::create_struct_skel},
-      {"create_constant", 	&POA_CORBA::StructDef::create_constant_skel},
-      {"create_value_box", 	&POA_CORBA::StructDef::create_value_box_skel},
-      {"contents", 	&POA_CORBA::StructDef::contents_skel},
-      {"create_alias", 	&POA_CORBA::StructDef::create_alias_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -6,  -3,   5,  -1,  -9,  -2, -63, -60,  11,  -1,  -1, 
-       12,  13,  14,  -1,  15, -17,  -2,  16, -60,  -1,  -1,  19,  20,  -1, 
-       21,  -1,  -1,  22,  23,  24, -26,  -2,  25, -60,  -1,  -1,  -1,  28, 
-       29,  -1,  -1,  30,  31,  -1,  32,  -1,  33,  34,  -1,  35,  -1,  -1, 
-       -1,  36, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_StructDef_Perfect_Hash_OpTable tao_CORBA_StructDef_optable;
-
-CORBA::StructDef_ptr _TAO_collocation_POA_CORBA_StructDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::StructDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_StructDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_StructDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_StructDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_StructDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_StructDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_StructDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_StructDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::StructDef::StructDef (void)
-{
-  this->optable_ = &tao_CORBA_StructDef_optable;
-}
-
-// copy ctor
-POA_CORBA::StructDef::StructDef (const StructDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,TypedefDef) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Container) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::StructDef::~StructDef (void)
-{
-}
-
-void POA_CORBA::StructDef::_get_members_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::StructDef *_tao_impl = (POA_CORBA::StructDef *)_tao_object_reference;
-
-  CORBA::StructMemberSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->members (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::StructDef::_set_members_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::StructDef *_tao_impl = (POA_CORBA::StructDef *)_tao_object_reference;
-
-  CORBA::StructMemberSeq members;
-  if (!(
-    (_tao_in >> members)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->members (
-        members,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::StructDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::StructDef *_tao_impl = (POA_CORBA::StructDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::StructDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::StructDef *_tao_impl = (POA_CORBA::StructDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::StructDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/StructDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::StructDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/StructDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::StructDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/TypedefDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::TypedefDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Container:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Container_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::StructDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::StructDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/StructDef:1.0";
-}
-
-CORBA::StructDef*
-POA_CORBA::StructDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::StructDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_StructDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::StructDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_StructDef::_tao_thru_poa_collocated_StructDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_TypedefDef) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Container) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_StructDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::StructDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/StructDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_StructDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::StructDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/StructDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::StructMemberSeq * POA_CORBA::_tao_thru_poa_collocated_StructDef::members  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::StructMemberSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "members",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::StructDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/StructDef:1.0"
-        )
-    )->members (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_StructDef::members  (
-    const CORBA::StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "members",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::StructDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/StructDef:1.0"
-        )
-    )->members (
-      members,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_UnionDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_UnionDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_UnionDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68,  0,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68,  0,
-     68,  8, 20,  0, 10, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68,  0,  0, 10,
-     68,  0, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 30, 30, 68, 68, 68,  5,  5, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68,
-#else
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
-     68, 68, 68, 68, 68,  0, 68,  0, 68,  8,
-     20,  0, 10, 68, 68, 68, 68, 68,  0,  0,
-     10, 68,  0, 68, 68, 30, 30, 68, 68, 68,
-      5,  5, 68, 68, 68, 68, 68, 68,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_UnionDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 35,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 27,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 67,
-      HASH_VALUE_RANGE = 64,
-      DUPLICATES = 7
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::UnionDef::move_skel},
-      {"_is_a",  &POA_CORBA::UnionDef::_is_a_skel},
-      {"lookup", 	&POA_CORBA::UnionDef::lookup_skel},
-      {"_get_name", 	&POA_CORBA::UnionDef::_get_name_skel},
-      {"_get_type", 	&POA_CORBA::UnionDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::UnionDef::_set_name_skel},
-      {"lookup_name", 	&POA_CORBA::UnionDef::lookup_name_skel},
-      {"_get_absolute_name", 	&POA_CORBA::UnionDef::_get_absolute_name_skel},
-      {"create_enum", 	&POA_CORBA::UnionDef::create_enum_skel},
-      {"create_value", 	&POA_CORBA::UnionDef::create_value_skel},
-      {"create_module", 	&POA_CORBA::UnionDef::create_module_skel},
-      {"_get_version", 	&POA_CORBA::UnionDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::UnionDef::_set_version_skel},
-      {"_get_discriminator_type", 	&POA_CORBA::UnionDef::_get_discriminator_type_skel},
-      {"create_interface", 	&POA_CORBA::UnionDef::create_interface_skel},
-      {"_get_defined_in", 	&POA_CORBA::UnionDef::_get_defined_in_skel},
-      {"_get_id", 	&POA_CORBA::UnionDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::UnionDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::UnionDef::describe_skel},
-      {"create_value_box", 	&POA_CORBA::UnionDef::create_value_box_skel},
-      {"create_union", 	&POA_CORBA::UnionDef::create_union_skel},
-      {"_get_containing_repository", 	&POA_CORBA::UnionDef::_get_containing_repository_skel},
-      {"destroy", 	&POA_CORBA::UnionDef::destroy_skel},
-      {"_get_def_kind", 	&POA_CORBA::UnionDef::_get_def_kind_skel},
-      {"create_exception", 	&POA_CORBA::UnionDef::create_exception_skel},
-      {"_get_discriminator_type_def", 	&POA_CORBA::UnionDef::_get_discriminator_type_def_skel},
-      {"_set_discriminator_type_def", 	&POA_CORBA::UnionDef::_set_discriminator_type_def_skel},
-      {"_get_members", 	&POA_CORBA::UnionDef::_get_members_skel},
-      {"_set_members", 	&POA_CORBA::UnionDef::_set_members_skel},
-      {"_non_existent",  &POA_CORBA::UnionDef::_non_existent_skel},
-      {"contents", 	&POA_CORBA::UnionDef::contents_skel},
-      {"create_alias", 	&POA_CORBA::UnionDef::create_alias_skel},
-      {"create_struct", 	&POA_CORBA::UnionDef::create_struct_skel},
-      {"create_constant", 	&POA_CORBA::UnionDef::create_constant_skel},
-      {"describe_contents", 	&POA_CORBA::UnionDef::describe_contents_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -1,   4,   5,   6,  -7,  -3, -69,  -1,  10,  -1,  -1, 
-      -15,  -2, -20,  -2,  11,  12,  13,  14, -75,  17,  18,  19,  -1, -78, 
-       22,  23,  24,  25,  26,  27,  28, -29,  -2, -69,  -1,  -1, -31,  -2, 
-      -69,  33,  -1,  -1,  34,  -1,  -1,  -1,  35,  36,  -1,  37,  -1,  -1, 
-       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  38, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_UnionDef_Perfect_Hash_OpTable tao_CORBA_UnionDef_optable;
-
-CORBA::UnionDef_ptr _TAO_collocation_POA_CORBA_UnionDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::UnionDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_UnionDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_UnionDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_UnionDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_UnionDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_UnionDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_UnionDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_UnionDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::UnionDef::UnionDef (void)
-{
-  this->optable_ = &tao_CORBA_UnionDef_optable;
-}
-
-// copy ctor
-POA_CORBA::UnionDef::UnionDef (const UnionDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,TypedefDef) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Container) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::UnionDef::~UnionDef (void)
-{
-}
-
-void POA_CORBA::UnionDef::_get_discriminator_type_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::UnionDef *_tao_impl = (POA_CORBA::UnionDef *)_tao_object_reference;
-
-  CORBA::TypeCode_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_discriminator_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->discriminator_type (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_discriminator_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_discriminator_type",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::UnionDef::_get_discriminator_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::UnionDef *_tao_impl = (POA_CORBA::UnionDef *)_tao_object_reference;
-
-  CORBA::IDLType_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_discriminator_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->discriminator_type_def (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_discriminator_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_discriminator_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::UnionDef::_set_discriminator_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::UnionDef *_tao_impl = (POA_CORBA::UnionDef *)_tao_object_reference;
-
-  CORBA::IDLType_var discriminator_type_def;
-  if (!(
-    (_tao_in >> discriminator_type_def.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_discriminator_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->discriminator_type_def (
-        discriminator_type_def.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_discriminator_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_discriminator_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::UnionDef::_get_members_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::UnionDef *_tao_impl = (POA_CORBA::UnionDef *)_tao_object_reference;
-
-  CORBA::UnionMemberSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->members (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::UnionDef::_set_members_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::UnionDef *_tao_impl = (POA_CORBA::UnionDef *)_tao_object_reference;
-
-  CORBA::UnionMemberSeq members;
-  if (!(
-    (_tao_in >> members)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->members (
-        members,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::UnionDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::UnionDef *_tao_impl = (POA_CORBA::UnionDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::UnionDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::UnionDef *_tao_impl = (POA_CORBA::UnionDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::UnionDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/UnionDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::UnionDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/UnionDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::UnionDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/TypedefDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::TypedefDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Container:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Container_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::UnionDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::UnionDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/UnionDef:1.0";
-}
-
-CORBA::UnionDef*
-POA_CORBA::UnionDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::UnionDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_UnionDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::UnionDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_UnionDef::_tao_thru_poa_collocated_UnionDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_TypedefDef) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Container) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_UnionDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::UnionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/UnionDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_UnionDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::UnionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/UnionDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_UnionDef::discriminator_type  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::TypeCode_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "discriminator_type",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::UnionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/UnionDef:1.0"
-        )
-    )->discriminator_type (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::IDLType_ptr POA_CORBA::_tao_thru_poa_collocated_UnionDef::discriminator_type_def  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::IDLType_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "discriminator_type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::UnionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/UnionDef:1.0"
-        )
-    )->discriminator_type_def (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_UnionDef::discriminator_type_def  (
-    CORBA::IDLType_ptr discriminator_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "discriminator_type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::UnionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/UnionDef:1.0"
-        )
-    )->discriminator_type_def (
-      discriminator_type_def,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::UnionMemberSeq * POA_CORBA::_tao_thru_poa_collocated_UnionDef::members  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::UnionMemberSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "members",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::UnionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/UnionDef:1.0"
-        )
-    )->members (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_UnionDef::members  (
-    const CORBA::UnionMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "members",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::UnionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/UnionDef:1.0"
-        )
-    )->members (
-      members,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_EnumDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_EnumDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_EnumDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37,  0,  0, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37,  0,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 10, 10, 37, 37, 37, 37, 10, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37,
-#else
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37,  0, 37,  0, 37, 37,
-      0,  0, 37, 37, 37, 37, 37, 37, 37,  0,
-      0, 37, 37, 37, 37, 10, 10, 37, 37, 37,
-     37, 10, 37, 37, 37, 37, 37, 37,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_EnumDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 18,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 36,
-      HASH_VALUE_RANGE = 33,
-      DUPLICATES = 6
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::EnumDef::move_skel},
-      {"_is_a",  &POA_CORBA::EnumDef::_is_a_skel},
-      {"_get_id", 	&POA_CORBA::EnumDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::EnumDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::EnumDef::describe_skel},
-      {"_get_name", 	&POA_CORBA::EnumDef::_get_name_skel},
-      {"_get_type", 	&POA_CORBA::EnumDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::EnumDef::_set_name_skel},
-      {"_get_version", 	&POA_CORBA::EnumDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::EnumDef::_set_version_skel},
-      {"_get_def_kind", 	&POA_CORBA::EnumDef::_get_def_kind_skel},
-      {"_get_defined_in", 	&POA_CORBA::EnumDef::_get_defined_in_skel},
-      {"destroy", 	&POA_CORBA::EnumDef::destroy_skel},
-      {"_get_absolute_name", 	&POA_CORBA::EnumDef::_get_absolute_name_skel},
-      {"_get_members", 	&POA_CORBA::EnumDef::_get_members_skel},
-      {"_set_members", 	&POA_CORBA::EnumDef::_set_members_skel},
-      {"_non_existent",  &POA_CORBA::EnumDef::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::EnumDef::_get_containing_repository_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -6,  -2,  -9,  -3,   4,   5,  -1, -43,   8, -43, -12,  -2, -38,  14, 
-       -1,  15,  -1,  16,  17,  -1, -18,  -2, -38,  20,  -1,  -1,  -1,  -1, 
-       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  21, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_EnumDef_Perfect_Hash_OpTable tao_CORBA_EnumDef_optable;
-
-CORBA::EnumDef_ptr _TAO_collocation_POA_CORBA_EnumDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::EnumDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_EnumDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_EnumDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_EnumDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_EnumDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_EnumDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_EnumDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_EnumDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::EnumDef::EnumDef (void)
-{
-  this->optable_ = &tao_CORBA_EnumDef_optable;
-}
-
-// copy ctor
-POA_CORBA::EnumDef::EnumDef (const EnumDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,TypedefDef) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::EnumDef::~EnumDef (void)
-{
-}
-
-void POA_CORBA::EnumDef::_get_members_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::EnumDef *_tao_impl = (POA_CORBA::EnumDef *)_tao_object_reference;
-
-  CORBA::EnumMemberSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->members (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::EnumDef::_set_members_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::EnumDef *_tao_impl = (POA_CORBA::EnumDef *)_tao_object_reference;
-
-  CORBA::EnumMemberSeq members;
-  if (!(
-    (_tao_in >> members)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->members (
-        members,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::EnumDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::EnumDef *_tao_impl = (POA_CORBA::EnumDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::EnumDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::EnumDef *_tao_impl = (POA_CORBA::EnumDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::EnumDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/EnumDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::EnumDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/EnumDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::EnumDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/TypedefDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::TypedefDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::EnumDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::EnumDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/EnumDef:1.0";
-}
-
-CORBA::EnumDef*
-POA_CORBA::EnumDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::EnumDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_EnumDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::EnumDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_EnumDef::_tao_thru_poa_collocated_EnumDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_TypedefDef) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_EnumDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::EnumDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/EnumDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_EnumDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::EnumDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/EnumDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::EnumMemberSeq * POA_CORBA::_tao_thru_poa_collocated_EnumDef::members  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::EnumMemberSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "members",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::EnumDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/EnumDef:1.0"
-        )
-    )->members (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_EnumDef::members  (
-    const CORBA::EnumMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "members",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::EnumDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/EnumDef:1.0"
-        )
-    )->members (
-      members,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_AliasDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_AliasDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_AliasDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37,  0,  0,  0, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37,  0,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 10, 37, 37, 37, 37, 10, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37,
-#else
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37,  0, 37,  0, 37, 37,
-      0,  0,  0, 37, 37, 37, 37, 37, 37,  0,
-      0, 37, 37, 37, 37, 37, 10, 37, 37, 37,
-     37, 10, 37, 37, 37, 37, 37, 37,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_AliasDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 18,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 36,
-      HASH_VALUE_RANGE = 33,
-      DUPLICATES = 6
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::AliasDef::move_skel},
-      {"_is_a",  &POA_CORBA::AliasDef::_is_a_skel},
-      {"_get_id", 	&POA_CORBA::AliasDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::AliasDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::AliasDef::describe_skel},
-      {"_get_name", 	&POA_CORBA::AliasDef::_get_name_skel},
-      {"_get_type", 	&POA_CORBA::AliasDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::AliasDef::_set_name_skel},
-      {"_get_version", 	&POA_CORBA::AliasDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::AliasDef::_set_version_skel},
-      {"_get_def_kind", 	&POA_CORBA::AliasDef::_get_def_kind_skel},
-      {"_get_defined_in", 	&POA_CORBA::AliasDef::_get_defined_in_skel},
-      {"destroy", 	&POA_CORBA::AliasDef::destroy_skel},
-      {"_get_absolute_name", 	&POA_CORBA::AliasDef::_get_absolute_name_skel},
-      {"_get_original_type_def", 	&POA_CORBA::AliasDef::_get_original_type_def_skel},
-      {"_set_original_type_def", 	&POA_CORBA::AliasDef::_set_original_type_def_skel},
-      {"_non_existent",  &POA_CORBA::AliasDef::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::AliasDef::_get_containing_repository_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -6,  -2,  -9,  -3,   4,   5,  -1, -43,   8, -43, -12,  -2, -38,  14, 
-       -1,  15,  -1,  16,  17,  -1, -18,  -2, -38,  20,  -1,  -1,  -1,  -1, 
-       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  21, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_AliasDef_Perfect_Hash_OpTable tao_CORBA_AliasDef_optable;
-
-CORBA::AliasDef_ptr _TAO_collocation_POA_CORBA_AliasDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::AliasDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_AliasDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_AliasDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_AliasDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_AliasDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_AliasDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_AliasDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_AliasDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::AliasDef::AliasDef (void)
-{
-  this->optable_ = &tao_CORBA_AliasDef_optable;
-}
-
-// copy ctor
-POA_CORBA::AliasDef::AliasDef (const AliasDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,TypedefDef) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::AliasDef::~AliasDef (void)
-{
-}
-
-void POA_CORBA::AliasDef::_get_original_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::AliasDef *_tao_impl = (POA_CORBA::AliasDef *)_tao_object_reference;
-
-  CORBA::IDLType_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_original_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->original_type_def (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_original_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_original_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::AliasDef::_set_original_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::AliasDef *_tao_impl = (POA_CORBA::AliasDef *)_tao_object_reference;
-
-  CORBA::IDLType_var original_type_def;
-  if (!(
-    (_tao_in >> original_type_def.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_original_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->original_type_def (
-        original_type_def.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_original_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_original_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::AliasDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::AliasDef *_tao_impl = (POA_CORBA::AliasDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::AliasDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::AliasDef *_tao_impl = (POA_CORBA::AliasDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::AliasDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/AliasDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/TypedefDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::AliasDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/AliasDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::AliasDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/TypedefDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::TypedefDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::AliasDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::AliasDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/AliasDef:1.0";
-}
-
-CORBA::AliasDef*
-POA_CORBA::AliasDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::AliasDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_AliasDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::AliasDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_AliasDef::_tao_thru_poa_collocated_AliasDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_TypedefDef) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_AliasDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::AliasDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AliasDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_AliasDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::AliasDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AliasDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::IDLType_ptr POA_CORBA::_tao_thru_poa_collocated_AliasDef::original_type_def  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::IDLType_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "original_type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::AliasDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AliasDef:1.0"
-        )
-    )->original_type_def (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_AliasDef::original_type_def  (
-    CORBA::IDLType_ptr original_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "original_type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::AliasDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AliasDef:1.0"
-        )
-    )->original_type_def (
-      original_type_def,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_PrimitiveDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_PrimitiveDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_PrimitiveDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19,  0,  5, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19,  5, 19, 19, 19, 19,  0, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19,
-#else
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19,  0, 19,  0, 19, 19,
-      0,  5, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19,  5, 19, 19, 19,
-     19,  0, 19, 19, 19, 19, 19, 19,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_PrimitiveDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 6,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 13,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 18,
-      HASH_VALUE_RANGE = 14,
-      DUPLICATES = 0
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::PrimitiveDef::_is_a_skel},
-      {"",0},
-      {"destroy", 	&POA_CORBA::PrimitiveDef::destroy_skel},
-      {"",0},
-      {"_get_kind", 	&POA_CORBA::PrimitiveDef::_get_kind_skel},
-      {"",0},{"",0},{"",0},
-      {"_get_def_kind", 	&POA_CORBA::PrimitiveDef::_get_def_kind_skel},
-      {"_get_type", 	&POA_CORBA::PrimitiveDef::_get_type_skel},
-      {"",0},{"",0},{"",0},
-      {"_non_existent",  &POA_CORBA::PrimitiveDef::_non_existent_skel},
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          const char *s = wordlist[key].opname_;
-
-          if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-            return &wordlist[key];
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_PrimitiveDef_Perfect_Hash_OpTable tao_CORBA_PrimitiveDef_optable;
-
-CORBA::PrimitiveDef_ptr _TAO_collocation_POA_CORBA_PrimitiveDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::PrimitiveDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_PrimitiveDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_PrimitiveDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_PrimitiveDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_PrimitiveDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_PrimitiveDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_PrimitiveDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_PrimitiveDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::PrimitiveDef::PrimitiveDef (void)
-{
-  this->optable_ = &tao_CORBA_PrimitiveDef_optable;
-}
-
-// copy ctor
-POA_CORBA::PrimitiveDef::PrimitiveDef (const PrimitiveDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::PrimitiveDef::~PrimitiveDef (void)
-{
-}
-
-void POA_CORBA::PrimitiveDef::_get_kind_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::PrimitiveDef *_tao_impl = (POA_CORBA::PrimitiveDef *)_tao_object_reference;
-
-  CORBA::PrimitiveKind _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_kind",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->kind (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_kind",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_kind",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::PrimitiveDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::PrimitiveDef *_tao_impl = (POA_CORBA::PrimitiveDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::PrimitiveDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::PrimitiveDef *_tao_impl = (POA_CORBA::PrimitiveDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::PrimitiveDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/PrimitiveDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::PrimitiveDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/PrimitiveDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::PrimitiveDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::PrimitiveDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::PrimitiveDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/PrimitiveDef:1.0";
-}
-
-CORBA::PrimitiveDef*
-POA_CORBA::PrimitiveDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::PrimitiveDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_PrimitiveDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::PrimitiveDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_PrimitiveDef::_tao_thru_poa_collocated_PrimitiveDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_PrimitiveDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::PrimitiveDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/PrimitiveDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_PrimitiveDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::PrimitiveDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/PrimitiveDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::PrimitiveKind POA_CORBA::_tao_thru_poa_collocated_PrimitiveDef::kind  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::PrimitiveKind _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "kind",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::PrimitiveDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/PrimitiveDef:1.0"
-        )
-    )->kind (
-      ACE_TRY_ENV
-    );
-
-}
-
-
-
-class TAO_CORBA_StringDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_StringDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_StringDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19,  0,  0, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19,  5, 19, 19, 19, 19,  0, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19,
-#else
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19,  0, 19,  0, 19, 19,
-      0,  0, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19,  5, 19, 19, 19,
-     19,  0, 19, 19, 19, 19, 19, 19,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_StringDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 7,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 13,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 18,
-      HASH_VALUE_RANGE = 14,
-      DUPLICATES = 2
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::StringDef::_is_a_skel},
-      {"destroy", 	&POA_CORBA::StringDef::destroy_skel},
-      {"_get_type", 	&POA_CORBA::StringDef::_get_type_skel},
-      {"_get_bound", 	&POA_CORBA::StringDef::_get_bound_skel},
-      {"_set_bound", 	&POA_CORBA::StringDef::_set_bound_skel},
-      {"_get_def_kind", 	&POA_CORBA::StringDef::_get_def_kind_skel},
-      {"_non_existent",  &POA_CORBA::StringDef::_non_existent_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -8,  -2,   5,  -1,   6,  -1,   7, -25,  -1,  -1,  10, 
-       -1,  -1,  -1,  -1,  11, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_StringDef_Perfect_Hash_OpTable tao_CORBA_StringDef_optable;
-
-CORBA::StringDef_ptr _TAO_collocation_POA_CORBA_StringDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::StringDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_StringDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_StringDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_StringDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_StringDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_StringDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_StringDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_StringDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::StringDef::StringDef (void)
-{
-  this->optable_ = &tao_CORBA_StringDef_optable;
-}
-
-// copy ctor
-POA_CORBA::StringDef::StringDef (const StringDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::StringDef::~StringDef (void)
-{
-}
-
-void POA_CORBA::StringDef::_get_bound_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::StringDef *_tao_impl = (POA_CORBA::StringDef *)_tao_object_reference;
-
-  CORBA::ULong _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->bound (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_bound",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::StringDef::_set_bound_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::StringDef *_tao_impl = (POA_CORBA::StringDef *)_tao_object_reference;
-
-  CORBA::ULong bound;
-  if (!(
-    (_tao_in >> bound)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->bound (
-        bound,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_bound",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::StringDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::StringDef *_tao_impl = (POA_CORBA::StringDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::StringDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::StringDef *_tao_impl = (POA_CORBA::StringDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::StringDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/StringDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::StringDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/StringDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::StringDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::StringDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::StringDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/StringDef:1.0";
-}
-
-CORBA::StringDef*
-POA_CORBA::StringDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::StringDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_StringDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::StringDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_StringDef::_tao_thru_poa_collocated_StringDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_StringDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::StringDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/StringDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_StringDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::StringDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/StringDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::ULong POA_CORBA::_tao_thru_poa_collocated_StringDef::bound  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ULong _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "bound",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::StringDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/StringDef:1.0"
-        )
-    )->bound (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_StringDef::bound  (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "bound",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::StringDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/StringDef:1.0"
-        )
-    )->bound (
-      bound,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_WstringDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_WstringDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_WstringDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19,  0,  0, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19,  5, 19, 19, 19, 19,  0, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19,
-#else
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19,  0, 19,  0, 19, 19,
-      0,  0, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19,  5, 19, 19, 19,
-     19,  0, 19, 19, 19, 19, 19, 19,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_WstringDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 7,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 13,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 18,
-      HASH_VALUE_RANGE = 14,
-      DUPLICATES = 2
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::WstringDef::_is_a_skel},
-      {"destroy", 	&POA_CORBA::WstringDef::destroy_skel},
-      {"_get_type", 	&POA_CORBA::WstringDef::_get_type_skel},
-      {"_get_bound", 	&POA_CORBA::WstringDef::_get_bound_skel},
-      {"_set_bound", 	&POA_CORBA::WstringDef::_set_bound_skel},
-      {"_get_def_kind", 	&POA_CORBA::WstringDef::_get_def_kind_skel},
-      {"_non_existent",  &POA_CORBA::WstringDef::_non_existent_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -8,  -2,   5,  -1,   6,  -1,   7, -25,  -1,  -1,  10, 
-       -1,  -1,  -1,  -1,  11, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_WstringDef_Perfect_Hash_OpTable tao_CORBA_WstringDef_optable;
-
-CORBA::WstringDef_ptr _TAO_collocation_POA_CORBA_WstringDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::WstringDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_WstringDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_WstringDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_WstringDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_WstringDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_WstringDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_WstringDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_WstringDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::WstringDef::WstringDef (void)
-{
-  this->optable_ = &tao_CORBA_WstringDef_optable;
-}
-
-// copy ctor
-POA_CORBA::WstringDef::WstringDef (const WstringDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::WstringDef::~WstringDef (void)
-{
-}
-
-void POA_CORBA::WstringDef::_get_bound_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::WstringDef *_tao_impl = (POA_CORBA::WstringDef *)_tao_object_reference;
-
-  CORBA::ULong _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->bound (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_bound",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::WstringDef::_set_bound_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::WstringDef *_tao_impl = (POA_CORBA::WstringDef *)_tao_object_reference;
-
-  CORBA::ULong bound;
-  if (!(
-    (_tao_in >> bound)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->bound (
-        bound,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_bound",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::WstringDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::WstringDef *_tao_impl = (POA_CORBA::WstringDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::WstringDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::WstringDef *_tao_impl = (POA_CORBA::WstringDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::WstringDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/WstringDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::WstringDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/WstringDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::WstringDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::WstringDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::WstringDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/WstringDef:1.0";
-}
-
-CORBA::WstringDef*
-POA_CORBA::WstringDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::WstringDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_WstringDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::WstringDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_WstringDef::_tao_thru_poa_collocated_WstringDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_WstringDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::WstringDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/WstringDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_WstringDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::WstringDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/WstringDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::ULong POA_CORBA::_tao_thru_poa_collocated_WstringDef::bound  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ULong _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "bound",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::WstringDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/WstringDef:1.0"
-        )
-    )->bound (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_WstringDef::bound  (
-    CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "bound",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::WstringDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/WstringDef:1.0"
-        )
-    )->bound (
-      bound,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_FixedDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_FixedDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_FixedDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19,  0,
-     19, 19,  0,  0, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19,  0,  5, 19, 19, 19, 19,  0, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19,
-#else
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19,  0, 19,  0, 19, 19,
-      0,  0, 19, 19, 19, 19, 19, 19, 19, 19,
-     19, 19, 19, 19, 19,  0,  5, 19, 19, 19,
-     19,  0, 19, 19, 19, 19, 19, 19,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_FixedDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 9,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 13,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 18,
-      HASH_VALUE_RANGE = 14,
-      DUPLICATES = 3
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::FixedDef::_is_a_skel},
-      {"destroy", 	&POA_CORBA::FixedDef::destroy_skel},
-      {"_get_type", 	&POA_CORBA::FixedDef::_get_type_skel},
-      {"_get_scale", 	&POA_CORBA::FixedDef::_get_scale_skel},
-      {"_set_scale", 	&POA_CORBA::FixedDef::_set_scale_skel},
-      {"_get_digits", 	&POA_CORBA::FixedDef::_get_digits_skel},
-      {"_set_digits", 	&POA_CORBA::FixedDef::_set_digits_skel},
-      {"_get_def_kind", 	&POA_CORBA::FixedDef::_get_def_kind_skel},
-      {"_non_existent",  &POA_CORBA::FixedDef::_non_existent_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -8,  -2, -10,  -2,   5,  -1,   6,  -1,   7, -27, -26,  -1,  12, 
-       -1,  -1,  -1,  -1,  13, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_FixedDef_Perfect_Hash_OpTable tao_CORBA_FixedDef_optable;
-
-CORBA::FixedDef_ptr _TAO_collocation_POA_CORBA_FixedDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::FixedDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_FixedDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_FixedDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_FixedDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_FixedDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_FixedDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_FixedDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_FixedDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::FixedDef::FixedDef (void)
-{
-  this->optable_ = &tao_CORBA_FixedDef_optable;
-}
-
-// copy ctor
-POA_CORBA::FixedDef::FixedDef (const FixedDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::FixedDef::~FixedDef (void)
-{
-}
-
-void POA_CORBA::FixedDef::_get_digits_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::FixedDef *_tao_impl = (POA_CORBA::FixedDef *)_tao_object_reference;
-
-  CORBA::UShort _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_digits",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->digits (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_digits",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_digits",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::FixedDef::_set_digits_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::FixedDef *_tao_impl = (POA_CORBA::FixedDef *)_tao_object_reference;
-
-  CORBA::UShort digits;
-  if (!(
-    (_tao_in >> digits)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_digits",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->digits (
-        digits,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_digits",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_digits",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::FixedDef::_get_scale_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::FixedDef *_tao_impl = (POA_CORBA::FixedDef *)_tao_object_reference;
-
-  CORBA::Short _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_scale",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->scale (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_scale",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_scale",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::FixedDef::_set_scale_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::FixedDef *_tao_impl = (POA_CORBA::FixedDef *)_tao_object_reference;
-
-  CORBA::Short scale;
-  if (!(
-    (_tao_in >> scale)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_scale",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->scale (
-        scale,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_scale",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_scale",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::FixedDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::FixedDef *_tao_impl = (POA_CORBA::FixedDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::FixedDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::FixedDef *_tao_impl = (POA_CORBA::FixedDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::FixedDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/FixedDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::FixedDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/FixedDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::FixedDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::FixedDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::FixedDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/FixedDef:1.0";
-}
-
-CORBA::FixedDef*
-POA_CORBA::FixedDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::FixedDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_FixedDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::FixedDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_FixedDef::_tao_thru_poa_collocated_FixedDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_FixedDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::FixedDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/FixedDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_FixedDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::FixedDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/FixedDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::UShort POA_CORBA::_tao_thru_poa_collocated_FixedDef::digits  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::UShort _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "digits",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::FixedDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/FixedDef:1.0"
-        )
-    )->digits (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_FixedDef::digits  (
-    CORBA::UShort digits,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "digits",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::FixedDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/FixedDef:1.0"
-        )
-    )->digits (
+    )->create_fixed_tc (
       digits,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::Short POA_CORBA::_tao_thru_poa_collocated_FixedDef::scale  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Short _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "scale",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::FixedDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/FixedDef:1.0"
-        )
-    )->scale (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_FixedDef::scale  (
-    CORBA::Short scale,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "scale",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::FixedDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/FixedDef:1.0"
-        )
-    )->scale (
       scale,
       ACE_TRY_ENV
     );
-  return;
-}
-
-
-
-class TAO_CORBA_SequenceDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_SequenceDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_SequenceDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22,  0,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22,  0,
-     22, 22,  0,  0,  0, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22,  5, 22, 22, 22, 22,  0, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22,
-#else
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22,  0, 22,  0, 22, 22,
-      0,  0,  0, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22,  5, 22, 22, 22,
-     22,  0, 22, 22, 22, 22, 22, 22,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_SequenceDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 10,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 21,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 21,
-      HASH_VALUE_RANGE = 17,
-      DUPLICATES = 3
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::SequenceDef::_is_a_skel},
-      {"destroy", 	&POA_CORBA::SequenceDef::destroy_skel},
-      {"_get_type", 	&POA_CORBA::SequenceDef::_get_type_skel},
-      {"_get_bound", 	&POA_CORBA::SequenceDef::_get_bound_skel},
-      {"_set_bound", 	&POA_CORBA::SequenceDef::_set_bound_skel},
-      {"_get_def_kind", 	&POA_CORBA::SequenceDef::_get_def_kind_skel},
-      {"_get_element_type", 	&POA_CORBA::SequenceDef::_get_element_type_skel},
-      {"_non_existent",  &POA_CORBA::SequenceDef::_non_existent_skel},
-      {"_get_element_type_def", 	&POA_CORBA::SequenceDef::_get_element_type_def_skel},
-      {"_set_element_type_def", 	&POA_CORBA::SequenceDef::_set_element_type_def_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -8,  -2,   5,  -1,   6,  -1,   7, -28,  -1,  -1,  10, 
-       -1,  -1,  -1,  11,  12, -13,  -2, -23, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_SequenceDef_Perfect_Hash_OpTable tao_CORBA_SequenceDef_optable;
-
-CORBA::SequenceDef_ptr _TAO_collocation_POA_CORBA_SequenceDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::SequenceDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_SequenceDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_SequenceDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_SequenceDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_SequenceDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_SequenceDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_SequenceDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_SequenceDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::SequenceDef::SequenceDef (void)
-{
-  this->optable_ = &tao_CORBA_SequenceDef_optable;
-}
-
-// copy ctor
-POA_CORBA::SequenceDef::SequenceDef (const SequenceDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::SequenceDef::~SequenceDef (void)
-{
-}
-
-void POA_CORBA::SequenceDef::_get_bound_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::SequenceDef *_tao_impl = (POA_CORBA::SequenceDef *)_tao_object_reference;
-
-  CORBA::ULong _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->bound (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_bound",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::SequenceDef::_set_bound_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::SequenceDef *_tao_impl = (POA_CORBA::SequenceDef *)_tao_object_reference;
-
-  CORBA::ULong bound;
-  if (!(
-    (_tao_in >> bound)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->bound (
-        bound,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_bound",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_bound",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::SequenceDef::_get_element_type_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::SequenceDef *_tao_impl = (POA_CORBA::SequenceDef *)_tao_object_reference;
-
-  CORBA::TypeCode_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->element_type (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::SequenceDef::_get_element_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::SequenceDef *_tao_impl = (POA_CORBA::SequenceDef *)_tao_object_reference;
-
-  CORBA::IDLType_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->element_type_def (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::SequenceDef::_set_element_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::SequenceDef *_tao_impl = (POA_CORBA::SequenceDef *)_tao_object_reference;
-
-  CORBA::IDLType_var element_type_def;
-  if (!(
-    (_tao_in >> element_type_def.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_element_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->element_type_def (
-        element_type_def.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_element_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_element_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::SequenceDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::SequenceDef *_tao_impl = (POA_CORBA::SequenceDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::SequenceDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::SequenceDef *_tao_impl = (POA_CORBA::SequenceDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::SequenceDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/SequenceDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::SequenceDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/SequenceDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::SequenceDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::SequenceDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::SequenceDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/SequenceDef:1.0";
-}
-
-CORBA::SequenceDef*
-POA_CORBA::SequenceDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::SequenceDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_SequenceDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::SequenceDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_SequenceDef::_tao_thru_poa_collocated_SequenceDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_SequenceDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::SequenceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/SequenceDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_SequenceDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::SequenceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/SequenceDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::ULong POA_CORBA::_tao_thru_poa_collocated_SequenceDef::bound  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ULong _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "bound",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::SequenceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/SequenceDef:1.0"
-        )
-    )->bound (
-      ACE_TRY_ENV
-    );
 
 }
 
-void POA_CORBA::_tao_thru_poa_collocated_SequenceDef::bound  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_sequence_tc  (
     CORBA::ULong bound,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "bound",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::SequenceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/SequenceDef:1.0"
-        )
-    )->bound (
-      bound,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_SequenceDef::element_type  (
+    CORBA::TypeCode_ptr element_type,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
@@ -14216,939 +3021,26 @@ CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_SequenceDef::element_typ
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "element_type",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::SequenceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/SequenceDef:1.0"
-        )
-    )->element_type (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::IDLType_ptr POA_CORBA::_tao_thru_poa_collocated_SequenceDef::element_type_def  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::IDLType_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "element_type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::SequenceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/SequenceDef:1.0"
-        )
-    )->element_type_def (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_SequenceDef::element_type_def  (
-    CORBA::IDLType_ptr element_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "element_type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::SequenceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/SequenceDef:1.0"
-        )
-    )->element_type_def (
-      element_type_def,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_ArrayDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:53 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_ArrayDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_ArrayDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22,  0,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22,  0,
-     22, 22,  0,  0,  0, 22,  0, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22,  5, 22, 22, 22, 22,  0, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22,
-#else
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22,  0, 22,  0, 22, 22,
-      0,  0,  0, 22,  0, 22, 22, 22, 22, 22,
-     22, 22, 22, 22, 22, 22,  5, 22, 22, 22,
-     22,  0, 22, 22, 22, 22, 22, 22,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_ArrayDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 10,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 21,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 21,
-      HASH_VALUE_RANGE = 17,
-      DUPLICATES = 3
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::ArrayDef::_is_a_skel},
-      {"destroy", 	&POA_CORBA::ArrayDef::destroy_skel},
-      {"_get_type", 	&POA_CORBA::ArrayDef::_get_type_skel},
-      {"_get_length", 	&POA_CORBA::ArrayDef::_get_length_skel},
-      {"_set_length", 	&POA_CORBA::ArrayDef::_set_length_skel},
-      {"_get_def_kind", 	&POA_CORBA::ArrayDef::_get_def_kind_skel},
-      {"_get_element_type", 	&POA_CORBA::ArrayDef::_get_element_type_skel},
-      {"_non_existent",  &POA_CORBA::ArrayDef::_non_existent_skel},
-      {"_get_element_type_def", 	&POA_CORBA::ArrayDef::_get_element_type_def_skel},
-      {"_set_element_type_def", 	&POA_CORBA::ArrayDef::_set_element_type_def_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -8,  -2,   5,  -1,   6,  -1,   7,  -1, -29,  -1,  10, 
-       -1,  -1,  -1,  11,  12, -13,  -2, -23, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:53 */
-static TAO_CORBA_ArrayDef_Perfect_Hash_OpTable tao_CORBA_ArrayDef_optable;
-
-CORBA::ArrayDef_ptr _TAO_collocation_POA_CORBA_ArrayDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::ArrayDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_ArrayDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_ArrayDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_ArrayDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_ArrayDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_ArrayDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_ArrayDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_ArrayDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::ArrayDef::ArrayDef (void)
-{
-  this->optable_ = &tao_CORBA_ArrayDef_optable;
-}
-
-// copy ctor
-POA_CORBA::ArrayDef::ArrayDef (const ArrayDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::ArrayDef::~ArrayDef (void)
-{
-}
-
-void POA_CORBA::ArrayDef::_get_length_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ArrayDef *_tao_impl = (POA_CORBA::ArrayDef *)_tao_object_reference;
-
-  CORBA::ULong _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_length",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->length (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_length",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_length",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ArrayDef::_set_length_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ArrayDef *_tao_impl = (POA_CORBA::ArrayDef *)_tao_object_reference;
-
-  CORBA::ULong length;
-  if (!(
-    (_tao_in >> length)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_length",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->length (
-        length,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_length",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_length",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ArrayDef::_get_element_type_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ArrayDef *_tao_impl = (POA_CORBA::ArrayDef *)_tao_object_reference;
-
-  CORBA::TypeCode_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->element_type (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ArrayDef::_get_element_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ArrayDef *_tao_impl = (POA_CORBA::ArrayDef *)_tao_object_reference;
-
-  CORBA::IDLType_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->element_type_def (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_element_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ArrayDef::_set_element_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ArrayDef *_tao_impl = (POA_CORBA::ArrayDef *)_tao_object_reference;
-
-  CORBA::IDLType_var element_type_def;
-  if (!(
-    (_tao_in >> element_type_def.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_element_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->element_type_def (
-        element_type_def.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_element_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_element_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ArrayDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ArrayDef *_tao_impl = (POA_CORBA::ArrayDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::ArrayDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::ArrayDef *_tao_impl = (POA_CORBA::ArrayDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::ArrayDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ArrayDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::ArrayDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/ArrayDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::ArrayDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::ArrayDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::ArrayDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/ArrayDef:1.0";
-}
-
-CORBA::ArrayDef*
-POA_CORBA::ArrayDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::ArrayDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_ArrayDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::ArrayDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_ArrayDef::_tao_thru_poa_collocated_ArrayDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ArrayDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
+      "create_sequence_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::ArrayDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ArrayDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ArrayDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ArrayDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ArrayDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::ULong POA_CORBA::_tao_thru_poa_collocated_ArrayDef::length  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ULong _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "length",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ArrayDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ArrayDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->length (
+    )->create_sequence_tc (
+      bound,
+      element_type,
       ACE_TRY_ENV
     );
 
 }
 
-void POA_CORBA::_tao_thru_poa_collocated_ArrayDef::length  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_array_tc  (
     CORBA::ULong length,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "length",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ArrayDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ArrayDef:1.0"
-        )
-    )->length (
-      length,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_ArrayDef::element_type  (
+    CORBA::TypeCode_ptr element_type,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
@@ -15162,737 +3054,29 @@ CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_ArrayDef::element_type
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "element_type",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ArrayDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ArrayDef:1.0"
-        )
-    )->element_type (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::IDLType_ptr POA_CORBA::_tao_thru_poa_collocated_ArrayDef::element_type_def  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::IDLType_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "element_type_def",
+      "create_array_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::ArrayDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ArrayDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->element_type_def (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ArrayDef::element_type_def  (
-    CORBA::IDLType_ptr element_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "element_type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ArrayDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ArrayDef:1.0"
-        )
-    )->element_type_def (
-      element_type_def,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_ExceptionDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:54 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_ExceptionDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_ExceptionDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52,  0,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52,  0,
-     52, 20,  3,  0, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 10, 15,  5,
-     52, 10, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 15, 15, 52, 52, 52, 15,  5, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52,
-#else
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52, 52, 52, 52, 52, 52,
-     52, 52, 52, 52, 52,  0, 52,  0, 52, 20,
-      3,  0, 52, 52, 52, 52, 52, 52, 10, 15,
-      5, 52, 10, 52, 52, 15, 15, 52, 52, 52,
-     15,  5, 52, 52, 52, 52, 52, 52,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_ExceptionDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 32,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 51,
-      HASH_VALUE_RANGE = 47,
-      DUPLICATES = 6
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::ExceptionDef::_is_a_skel},
-      {"_get_type", 	&POA_CORBA::ExceptionDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::ExceptionDef::_set_name_skel},
-      {"_get_name", 	&POA_CORBA::ExceptionDef::_get_name_skel},
-      {"_get_id", 	&POA_CORBA::ExceptionDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::ExceptionDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::ExceptionDef::describe_skel},
-      {"destroy", 	&POA_CORBA::ExceptionDef::destroy_skel},
-      {"_get_def_kind", 	&POA_CORBA::ExceptionDef::_get_def_kind_skel},
-      {"_get_version", 	&POA_CORBA::ExceptionDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::ExceptionDef::_set_version_skel},
-      {"_get_absolute_name", 	&POA_CORBA::ExceptionDef::_get_absolute_name_skel},
-      {"move", 	&POA_CORBA::ExceptionDef::move_skel},
-      {"_get_defined_in", 	&POA_CORBA::ExceptionDef::_get_defined_in_skel},
-      {"lookup_name", 	&POA_CORBA::ExceptionDef::lookup_name_skel},
-      {"lookup", 	&POA_CORBA::ExceptionDef::lookup_skel},
-      {"_get_members", 	&POA_CORBA::ExceptionDef::_get_members_skel},
-      {"_set_members", 	&POA_CORBA::ExceptionDef::_set_members_skel},
-      {"_non_existent",  &POA_CORBA::ExceptionDef::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::ExceptionDef::_get_containing_repository_skel},
-      {"create_value", 	&POA_CORBA::ExceptionDef::create_value_skel},
-      {"create_module", 	&POA_CORBA::ExceptionDef::create_module_skel},
-      {"describe_contents", 	&POA_CORBA::ExceptionDef::describe_contents_skel},
-      {"create_interface", 	&POA_CORBA::ExceptionDef::create_interface_skel},
-      {"create_union", 	&POA_CORBA::ExceptionDef::create_union_skel},
-      {"create_exception", 	&POA_CORBA::ExceptionDef::create_exception_skel},
-      {"contents", 	&POA_CORBA::ExceptionDef::contents_skel},
-      {"create_enum", 	&POA_CORBA::ExceptionDef::create_enum_skel},
-      {"create_alias", 	&POA_CORBA::ExceptionDef::create_alias_skel},
-      {"create_struct", 	&POA_CORBA::ExceptionDef::create_struct_skel},
-      {"create_constant", 	&POA_CORBA::ExceptionDef::create_constant_skel},
-      {"create_value_box", 	&POA_CORBA::ExceptionDef::create_value_box_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -6,  -3,   5,  -1,  -9,  -2, -57, -54,  11,  -1, -14, 
-       -2,  12,  13, -55,  16,  17,  18,  19,  -1,  -1, -21,  -2,  20, -54, 
-       23,  -1,  -1,  24,  25,  26,  -1,  27,  28,  29,  -1,  -1,  -1,  30, 
-       -1,  31,  -1,  -1,  32,  33,  34,  -1,  35,  36, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:54 */
-static TAO_CORBA_ExceptionDef_Perfect_Hash_OpTable tao_CORBA_ExceptionDef_optable;
-
-CORBA::ExceptionDef_ptr _TAO_collocation_POA_CORBA_ExceptionDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::ExceptionDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_ExceptionDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_ExceptionDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_ExceptionDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_ExceptionDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_ExceptionDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_ExceptionDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_ExceptionDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::ExceptionDef::ExceptionDef (void)
-{
-  this->optable_ = &tao_CORBA_ExceptionDef_optable;
-}
-
-// copy ctor
-POA_CORBA::ExceptionDef::ExceptionDef (const ExceptionDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Container) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::ExceptionDef::~ExceptionDef (void)
-{
-}
-
-void POA_CORBA::ExceptionDef::_get_type_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ExceptionDef *_tao_impl = (POA_CORBA::ExceptionDef *)_tao_object_reference;
-
-  CORBA::TypeCode_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->type (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ExceptionDef::_get_members_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ExceptionDef *_tao_impl = (POA_CORBA::ExceptionDef *)_tao_object_reference;
-
-  CORBA::StructMemberSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->members (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_members",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ExceptionDef::_set_members_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ExceptionDef *_tao_impl = (POA_CORBA::ExceptionDef *)_tao_object_reference;
-
-  CORBA::StructMemberSeq members;
-  if (!(
-    (_tao_in >> members)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->members (
-        members,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_members",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ExceptionDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ExceptionDef *_tao_impl = (POA_CORBA::ExceptionDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::ExceptionDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::ExceptionDef *_tao_impl = (POA_CORBA::ExceptionDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::ExceptionDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ExceptionDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::ExceptionDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/ExceptionDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::ExceptionDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Container:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Container_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::ExceptionDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::ExceptionDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/ExceptionDef:1.0";
-}
-
-CORBA::ExceptionDef*
-POA_CORBA::ExceptionDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::ExceptionDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_ExceptionDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::ExceptionDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_ExceptionDef::_tao_thru_poa_collocated_ExceptionDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Container) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ExceptionDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
+    )->create_array_tc (
+      length,
+      element_type,
       ACE_TRY_ENV
     );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ExceptionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ExceptionDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
 
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ExceptionDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ExceptionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ExceptionDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
 }
 
-
-CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_ExceptionDef::type  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_value_tc  (
+    const char * id,
+    const char * name,
+    CORBA::ValueModifier type_modifier,
+    CORBA::TypeCode_ptr concrete_base,
+    const IR::ValueMemberSeq & members,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
@@ -15906,4739 +3090,96 @@ CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_ExceptionDef::type  (
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "type",
+      "create_value_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::ExceptionDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ExceptionDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->type (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::StructMemberSeq * POA_CORBA::_tao_thru_poa_collocated_ExceptionDef::members  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::StructMemberSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "members",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ExceptionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ExceptionDef:1.0"
-        )
-    )->members (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ExceptionDef::members  (
-    const CORBA::StructMemberSeq & members,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "members",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ExceptionDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ExceptionDef:1.0"
-        )
-    )->members (
+    )->create_value_tc (
+      id,
+      name,
+      type_modifier,
+      concrete_base,
       members,
       ACE_TRY_ENV
     );
-  return;
-}
-
-
 
-class TAO_CORBA_AttributeDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:54 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_AttributeDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_AttributeDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37,  0,  0, 10, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37,  0,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 15, 37, 37, 37, 37, 10, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37,
-#else
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37,  0, 37,  0, 37, 37,
-      0,  0, 10, 37, 37, 37, 37, 37, 37,  0,
-      0, 37, 37, 37, 37, 37, 15, 37, 37, 37,
-     37, 10, 37, 37, 37, 37, 37, 37,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_AttributeDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 20,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 36,
-      HASH_VALUE_RANGE = 33,
-      DUPLICATES = 8
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::AttributeDef::move_skel},
-      {"_is_a",  &POA_CORBA::AttributeDef::_is_a_skel},
-      {"_get_id", 	&POA_CORBA::AttributeDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::AttributeDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::AttributeDef::describe_skel},
-      {"_get_type", 	&POA_CORBA::AttributeDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::AttributeDef::_set_name_skel},
-      {"_get_name", 	&POA_CORBA::AttributeDef::_get_name_skel},
-      {"_set_mode", 	&POA_CORBA::AttributeDef::_set_mode_skel},
-      {"_get_mode", 	&POA_CORBA::AttributeDef::_get_mode_skel},
-      {"_get_version", 	&POA_CORBA::AttributeDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::AttributeDef::_set_version_skel},
-      {"_get_def_kind", 	&POA_CORBA::AttributeDef::_get_def_kind_skel},
-      {"_get_defined_in", 	&POA_CORBA::AttributeDef::_get_defined_in_skel},
-      {"destroy", 	&POA_CORBA::AttributeDef::destroy_skel},
-      {"_get_absolute_name", 	&POA_CORBA::AttributeDef::_get_absolute_name_skel},
-      {"_get_type_def", 	&POA_CORBA::AttributeDef::_get_type_def_skel},
-      {"_set_type_def", 	&POA_CORBA::AttributeDef::_set_type_def_skel},
-      {"_non_existent",  &POA_CORBA::AttributeDef::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::AttributeDef::_get_containing_repository_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -6,  -2,  -9,  -5,   4,   5,  -1, -43,   8, -43, -14,  -2, -38,  16, 
-       -1,  17,  -1,  18,  19,  -1,  -1, -20,  -2, -38,  -1,  -1,  -1,  -1, 
-       22,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  23, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:54 */
-static TAO_CORBA_AttributeDef_Perfect_Hash_OpTable tao_CORBA_AttributeDef_optable;
-
-CORBA::AttributeDef_ptr _TAO_collocation_POA_CORBA_AttributeDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::AttributeDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_AttributeDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_AttributeDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_AttributeDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_AttributeDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_AttributeDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_AttributeDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_AttributeDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::AttributeDef::AttributeDef (void)
-{
-  this->optable_ = &tao_CORBA_AttributeDef_optable;
-}
-
-// copy ctor
-POA_CORBA::AttributeDef::AttributeDef (const AttributeDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::AttributeDef::~AttributeDef (void)
-{
 }
 
-void POA_CORBA::AttributeDef::_get_type_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::AttributeDef *_tao_impl = (POA_CORBA::AttributeDef *)_tao_object_reference;
-
-  CORBA::TypeCode_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->type (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::AttributeDef::_get_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::AttributeDef *_tao_impl = (POA_CORBA::AttributeDef *)_tao_object_reference;
-
-  CORBA::IDLType_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->type_def (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::AttributeDef::_set_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::AttributeDef *_tao_impl = (POA_CORBA::AttributeDef *)_tao_object_reference;
-
-  CORBA::IDLType_var type_def;
-  if (!(
-    (_tao_in >> type_def.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->type_def (
-        type_def.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::AttributeDef::_get_mode_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::AttributeDef *_tao_impl = (POA_CORBA::AttributeDef *)_tao_object_reference;
-
-  CORBA::AttributeMode _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_mode",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->mode (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_mode",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_mode",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::AttributeDef::_set_mode_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::AttributeDef *_tao_impl = (POA_CORBA::AttributeDef *)_tao_object_reference;
-
-  CORBA::AttributeMode mode;
-  if (!(
-    (_tao_in >> mode)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_mode",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->mode (
-        mode,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_mode",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_mode",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::AttributeDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::AttributeDef *_tao_impl = (POA_CORBA::AttributeDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::AttributeDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::AttributeDef *_tao_impl = (POA_CORBA::AttributeDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::AttributeDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/AttributeDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::AttributeDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/AttributeDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::AttributeDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::AttributeDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::AttributeDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/AttributeDef:1.0";
-}
-
-CORBA::AttributeDef*
-POA_CORBA::AttributeDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::AttributeDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_AttributeDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::AttributeDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_AttributeDef::_tao_thru_poa_collocated_AttributeDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_AttributeDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::AttributeDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AttributeDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_AttributeDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::AttributeDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AttributeDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_AttributeDef::type  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::TypeCode_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "type",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::AttributeDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AttributeDef:1.0"
-        )
-    )->type (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::IDLType_ptr POA_CORBA::_tao_thru_poa_collocated_AttributeDef::type_def  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::IDLType_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::AttributeDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AttributeDef:1.0"
-        )
-    )->type_def (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_AttributeDef::type_def  (
-    CORBA::IDLType_ptr type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::AttributeDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AttributeDef:1.0"
-        )
-    )->type_def (
-      type_def,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::AttributeMode POA_CORBA::_tao_thru_poa_collocated_AttributeDef::mode  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::AttributeMode _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "mode",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::AttributeDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AttributeDef:1.0"
-        )
-    )->mode (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_AttributeDef::mode  (
-    CORBA::AttributeMode mode,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "mode",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::AttributeDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/AttributeDef:1.0"
-        )
-    )->mode (
-      mode,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_OperationDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:54 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_OperationDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_OperationDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37, 15,  0, 10, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37,  0,  5,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37,  0, 20, 37, 37, 37, 37, 10, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37,
-#else
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37,  0, 37,  0, 37, 37,
-     15,  0, 10, 37, 37, 37, 37, 37, 37,  0,
-      5, 37, 37, 37, 37,  0, 20, 37, 37, 37,
-     37, 10, 37, 37, 37, 37, 37, 37,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_OperationDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 26,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 36,
-      HASH_VALUE_RANGE = 33,
-      DUPLICATES = 10
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::OperationDef::move_skel},
-      {"_is_a",  &POA_CORBA::OperationDef::_is_a_skel},
-      {"_get_mode", 	&POA_CORBA::OperationDef::_get_mode_skel},
-      {"_set_name", 	&POA_CORBA::OperationDef::_set_name_skel},
-      {"_get_name", 	&POA_CORBA::OperationDef::_get_name_skel},
-      {"_set_mode", 	&POA_CORBA::OperationDef::_set_mode_skel},
-      {"_get_params", 	&POA_CORBA::OperationDef::_get_params_skel},
-      {"_set_params", 	&POA_CORBA::OperationDef::_set_params_skel},
-      {"_get_contexts", 	&POA_CORBA::OperationDef::_get_contexts_skel},
-      {"_set_contexts", 	&POA_CORBA::OperationDef::_set_contexts_skel},
-      {"_get_exceptions", 	&POA_CORBA::OperationDef::_get_exceptions_skel},
-      {"_set_exceptions", 	&POA_CORBA::OperationDef::_set_exceptions_skel},
-      {"_get_version", 	&POA_CORBA::OperationDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::OperationDef::_set_version_skel},
-      {"_get_absolute_name", 	&POA_CORBA::OperationDef::_get_absolute_name_skel},
-      {"_get_defined_in", 	&POA_CORBA::OperationDef::_get_defined_in_skel},
-      {"_get_id", 	&POA_CORBA::OperationDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::OperationDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::OperationDef::describe_skel},
-      {"_get_result_def", 	&POA_CORBA::OperationDef::_get_result_def_skel},
-      {"_set_result_def", 	&POA_CORBA::OperationDef::_set_result_def_skel},
-      {"_get_def_kind", 	&POA_CORBA::OperationDef::_get_def_kind_skel},
-      {"_get_result", 	&POA_CORBA::OperationDef::_get_result_skel},
-      {"destroy", 	&POA_CORBA::OperationDef::destroy_skel},
-      {"_non_existent",  &POA_CORBA::OperationDef::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::OperationDef::_get_containing_repository_skel},
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-            {
-              const class TAO_operation_db_entry   *resword; 
-
-              switch (key)
-                {
-                case   4:
-                  resword = &wordlist[4]; break;
-                case   5:
-                  resword = &wordlist[5]; break;
-                case   9:
-                  resword = &wordlist[6];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  resword = &wordlist[7];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  resword = &wordlist[8];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  resword = &wordlist[9];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  return 0;
-                case  11:
-                  resword = &wordlist[10];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  resword = &wordlist[11];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  return 0;
-                case  13:
-                  resword = &wordlist[12];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  resword = &wordlist[13];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  return 0;
-                case  15:
-                  resword = &wordlist[14];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  resword = &wordlist[15];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  return 0;
-                case  17:
-                  resword = &wordlist[16];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  resword = &wordlist[17];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  return 0;
-                case  18:
-                  resword = &wordlist[18]; break;
-                case  20:
-                  resword = &wordlist[19]; break;
-                case  22:
-                  resword = &wordlist[20];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  resword = &wordlist[21];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  return 0;
-                case  23:
-                  resword = &wordlist[22]; break;
-                case  25:
-                  resword = &wordlist[23];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  resword = &wordlist[24];
-                  if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1)) return resword;
-                  return 0;
-                case  28:
-                  resword = &wordlist[25]; break;
-                case  31:
-                  resword = &wordlist[26]; break;
-                case  32:
-                  resword = &wordlist[27]; break;
-                case  33:
-                  resword = &wordlist[28]; break;
-                case  36:
-                  resword = &wordlist[29]; break;
-                default: return 0;
-                }
-              if (*str == *resword->opname_ && !strncmp (str + 1, resword->opname_ + 1, len - 1))
-                return resword;
-              return 0;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:54 */
-static TAO_CORBA_OperationDef_Perfect_Hash_OpTable tao_CORBA_OperationDef_optable;
-
-CORBA::OperationDef_ptr _TAO_collocation_POA_CORBA_OperationDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::OperationDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_OperationDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_OperationDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_OperationDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_OperationDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_OperationDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_OperationDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_OperationDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::OperationDef::OperationDef (void)
-{
-  this->optable_ = &tao_CORBA_OperationDef_optable;
-}
-
-// copy ctor
-POA_CORBA::OperationDef::OperationDef (const OperationDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::OperationDef::~OperationDef (void)
-{
-}
-
-void POA_CORBA::OperationDef::_get_result_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::TypeCode_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_result",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->result (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_result",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_result",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::OperationDef::_get_result_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::IDLType_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_result_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->result_def (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_result_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_result_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::OperationDef::_set_result_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::IDLType_var result_def;
-  if (!(
-    (_tao_in >> result_def.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_result_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->result_def (
-        result_def.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_result_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_result_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::OperationDef::_get_params_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::ParDescriptionSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_params",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->params (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_params",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_params",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::OperationDef::_set_params_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::ParDescriptionSeq params;
-  if (!(
-    (_tao_in >> params)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_params",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->params (
-        params,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_params",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_params",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::OperationDef::_get_mode_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::OperationMode _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_mode",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->mode (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_mode",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_mode",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::OperationDef::_set_mode_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::OperationMode mode;
-  if (!(
-    (_tao_in >> mode)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_mode",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->mode (
-        mode,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_mode",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_mode",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::OperationDef::_get_contexts_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::ContextIdSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_contexts",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->contexts (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_contexts",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_contexts",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::OperationDef::_set_contexts_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::ContextIdSeq contexts;
-  if (!(
-    (_tao_in >> contexts)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_contexts",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->contexts (
-        contexts,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_contexts",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_contexts",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::OperationDef::_get_exceptions_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::ExceptionDefSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_exceptions",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->exceptions (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_exceptions",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_exceptions",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::OperationDef::_set_exceptions_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *)_tao_object_reference;
-
-  CORBA::ExceptionDefSeq exceptions;
-  if (!(
-    (_tao_in >> exceptions)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_exceptions",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->exceptions (
-        exceptions,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_exceptions",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_exceptions",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::OperationDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::OperationDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::OperationDef *_tao_impl = (POA_CORBA::OperationDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::OperationDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/OperationDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::OperationDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/OperationDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::OperationDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::OperationDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::OperationDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/OperationDef:1.0";
-}
-
-CORBA::OperationDef*
-POA_CORBA::OperationDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::OperationDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_OperationDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::OperationDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_OperationDef::_tao_thru_poa_collocated_OperationDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_OperationDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_OperationDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_OperationDef::result  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::TypeCode_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "result",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->result (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::IDLType_ptr POA_CORBA::_tao_thru_poa_collocated_OperationDef::result_def  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::IDLType_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "result_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->result_def (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_OperationDef::result_def  (
-    CORBA::IDLType_ptr result_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "result_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->result_def (
-      result_def,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::ParDescriptionSeq * POA_CORBA::_tao_thru_poa_collocated_OperationDef::params  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ParDescriptionSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "params",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->params (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_OperationDef::params  (
-    const CORBA::ParDescriptionSeq & params,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "params",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->params (
-      params,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::OperationMode POA_CORBA::_tao_thru_poa_collocated_OperationDef::mode  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::OperationMode _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "mode",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->mode (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_OperationDef::mode  (
-    CORBA::OperationMode mode,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "mode",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->mode (
-      mode,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::ContextIdSeq * POA_CORBA::_tao_thru_poa_collocated_OperationDef::contexts  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ContextIdSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "contexts",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->contexts (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_OperationDef::contexts  (
-    const CORBA::ContextIdSeq & contexts,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "contexts",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->contexts (
-      contexts,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::ExceptionDefSeq * POA_CORBA::_tao_thru_poa_collocated_OperationDef::exceptions  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ExceptionDefSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "exceptions",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->exceptions (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_OperationDef::exceptions  (
-    const CORBA::ExceptionDefSeq & exceptions,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "exceptions",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::OperationDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/OperationDef:1.0"
-        )
-    )->exceptions (
-      exceptions,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_InterfaceDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:54 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_InterfaceDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_InterfaceDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71,  0,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71,  0,
-     71, 25, 15,  0, 71, 71, 71, 10, 71, 71,
-     71, 71, 71, 71, 71, 71, 71,  0,  0,  5,
-     71,  0, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 15, 30, 71, 71, 71, 10,  5, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71,
-#else
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71, 71, 71, 71, 71, 71,
-     71, 71, 71, 71, 71,  0, 71,  0, 71, 25,
-     15,  0, 71, 71, 71, 10, 71, 71,  0,  0,
-      5, 71,  0, 71, 71, 15, 30, 71, 71, 71,
-     10,  5, 71, 71, 71, 71, 71, 71,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_InterfaceDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 36,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 70,
-      HASH_VALUE_RANGE = 67,
-      DUPLICATES = 8
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::InterfaceDef::move_skel},
-      {"_is_a",  &POA_CORBA::InterfaceDef::_is_a_skel},
-      {"lookup", 	&POA_CORBA::InterfaceDef::lookup_skel},
-      {"_get_name", 	&POA_CORBA::InterfaceDef::_get_name_skel},
-      {"_get_type", 	&POA_CORBA::InterfaceDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::InterfaceDef::_set_name_skel},
-      {"lookup_name", 	&POA_CORBA::InterfaceDef::lookup_name_skel},
-      {"is_a", 	&POA_CORBA::InterfaceDef::is_a_skel},
-      {"_get_version", 	&POA_CORBA::InterfaceDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::InterfaceDef::_set_version_skel},
-      {"_get_absolute_name", 	&POA_CORBA::InterfaceDef::_get_absolute_name_skel},
-      {"_get_defined_in", 	&POA_CORBA::InterfaceDef::_get_defined_in_skel},
-      {"_get_id", 	&POA_CORBA::InterfaceDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::InterfaceDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::InterfaceDef::describe_skel},
-      {"destroy", 	&POA_CORBA::InterfaceDef::destroy_skel},
-      {"_get_def_kind", 	&POA_CORBA::InterfaceDef::_get_def_kind_skel},
-      {"_get_containing_repository", 	&POA_CORBA::InterfaceDef::_get_containing_repository_skel},
-      {"describe_interface", 	&POA_CORBA::InterfaceDef::describe_interface_skel},
-      {"_get_base_interfaces", 	&POA_CORBA::InterfaceDef::_get_base_interfaces_skel},
-      {"_set_base_interfaces", 	&POA_CORBA::InterfaceDef::_set_base_interfaces_skel},
-      {"create_enum", 	&POA_CORBA::InterfaceDef::create_enum_skel},
-      {"create_value", 	&POA_CORBA::InterfaceDef::create_value_skel},
-      {"create_module", 	&POA_CORBA::InterfaceDef::create_module_skel},
-      {"create_attribute", 	&POA_CORBA::InterfaceDef::create_attribute_skel},
-      {"create_interface", 	&POA_CORBA::InterfaceDef::create_interface_skel},
-      {"create_union", 	&POA_CORBA::InterfaceDef::create_union_skel},
-      {"_non_existent",  &POA_CORBA::InterfaceDef::_non_existent_skel},
-      {"create_operation", 	&POA_CORBA::InterfaceDef::create_operation_skel},
-      {"create_exception", 	&POA_CORBA::InterfaceDef::create_exception_skel},
-      {"describe_contents", 	&POA_CORBA::InterfaceDef::describe_contents_skel},
-      {"contents", 	&POA_CORBA::InterfaceDef::contents_skel},
-      {"create_value_box", 	&POA_CORBA::InterfaceDef::create_value_box_skel},
-      {"create_alias", 	&POA_CORBA::InterfaceDef::create_alias_skel},
-      {"create_struct", 	&POA_CORBA::InterfaceDef::create_struct_skel},
-      {"create_constant", 	&POA_CORBA::InterfaceDef::create_constant_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -1,   4,   5,   6,  -7,  -3, -72,  -1,  10, -12,  -2, 
-       11, -16,  -2, -75,  14,  -1,  15,  -1, -77,  18,  -1,  -1,  -1,  19, 
-       20, -23,  -2,  21,  -1,  22,  -1, -76,  25,  26,  27, -28,  -2, -72, 
-       30,  31, -32,  -2, -72,  34,  35,  -1,  -1,  36,  37,  -1,  -1,  -1, 
-       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  38,  -1, 
-       39, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:54 */
-static TAO_CORBA_InterfaceDef_Perfect_Hash_OpTable tao_CORBA_InterfaceDef_optable;
-
-CORBA::InterfaceDef_ptr _TAO_collocation_POA_CORBA_InterfaceDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::InterfaceDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_InterfaceDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_InterfaceDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_InterfaceDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_InterfaceDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_InterfaceDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_InterfaceDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_InterfaceDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::InterfaceDef::InterfaceDef (void)
-{
-  this->optable_ = &tao_CORBA_InterfaceDef_optable;
-}
-
-// copy ctor
-POA_CORBA::InterfaceDef::InterfaceDef (const InterfaceDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Container) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::InterfaceDef::~InterfaceDef (void)
-{
-}
-
-void POA_CORBA::InterfaceDef::_get_base_interfaces_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::InterfaceDef *_tao_impl = (POA_CORBA::InterfaceDef *)_tao_object_reference;
-
-  CORBA::InterfaceDefSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_base_interfaces",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->base_interfaces (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_base_interfaces",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_base_interfaces",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::InterfaceDef::_set_base_interfaces_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::InterfaceDef *_tao_impl = (POA_CORBA::InterfaceDef *)_tao_object_reference;
-
-  CORBA::InterfaceDefSeq base_interfaces;
-  if (!(
-    (_tao_in >> base_interfaces)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_base_interfaces",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->base_interfaces (
-        base_interfaces,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_base_interfaces",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_base_interfaces",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::InterfaceDef::is_a_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::InterfaceDef *_tao_impl = (POA_CORBA::InterfaceDef *)_tao_object_reference;
-
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var interface_id;
-  if (!(
-    (_tao_in >> interface_id.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "is_a",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->is_a (
-        interface_id.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "is_a",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "is_a",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << CORBA::Any::from_boolean (_tao_retval))
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::InterfaceDef::describe_interface_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::InterfaceDef *_tao_impl = (POA_CORBA::InterfaceDef *)_tao_object_reference;
-
-  CORBA::InterfaceDef::FullInterfaceDescription_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "describe_interface",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->describe_interface (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "describe_interface",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "describe_interface",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::InterfaceDef::create_attribute_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::InterfaceDef *_tao_impl = (POA_CORBA::InterfaceDef *)_tao_object_reference;
-
-  CORBA::AttributeDef_var _tao_retval;
-  CORBA::String_var id;
-  CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::IDLType_var type;
-  CORBA::AttributeMode mode;
-  if (!(
-    (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> type.out ()) &&
-    (_tao_in >> mode)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_attribute",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_attribute (
-        id.in (),
-        name.in (),
-        version.in (),
-        type.in (),
-        mode,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_attribute",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_attribute",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::InterfaceDef::create_operation_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::InterfaceDef *_tao_impl = (POA_CORBA::InterfaceDef *)_tao_object_reference;
-
-  CORBA::OperationDef_var _tao_retval;
-  CORBA::String_var id;
-  CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::IDLType_var result;
-  CORBA::OperationMode mode;
-  CORBA::ParDescriptionSeq params;
-  CORBA::ExceptionDefSeq exceptions;
-  CORBA::ContextIdSeq contexts;
-  if (!(
-    (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> result.out ()) &&
-    (_tao_in >> mode) &&
-    (_tao_in >> params) &&
-    (_tao_in >> exceptions) &&
-    (_tao_in >> contexts)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_operation",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_operation (
-        id.in (),
-        name.in (),
-        version.in (),
-        result.in (),
-        mode,
-        params,
-        exceptions,
-        contexts,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_operation",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_operation",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::InterfaceDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::InterfaceDef *_tao_impl = (POA_CORBA::InterfaceDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::InterfaceDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::InterfaceDef *_tao_impl = (POA_CORBA::InterfaceDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::InterfaceDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/InterfaceDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::InterfaceDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/InterfaceDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::InterfaceDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Container:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Container_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::InterfaceDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::InterfaceDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/InterfaceDef:1.0";
-}
-
-CORBA::InterfaceDef*
-POA_CORBA::InterfaceDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::InterfaceDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_InterfaceDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::InterfaceDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_InterfaceDef::_tao_thru_poa_collocated_InterfaceDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Container) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_InterfaceDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::InterfaceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/InterfaceDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_InterfaceDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::InterfaceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/InterfaceDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::InterfaceDefSeq * POA_CORBA::_tao_thru_poa_collocated_InterfaceDef::base_interfaces  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::InterfaceDefSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "base_interfaces",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::InterfaceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/InterfaceDef:1.0"
-        )
-    )->base_interfaces (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_InterfaceDef::base_interfaces  (
-    const CORBA::InterfaceDefSeq & base_interfaces,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "base_interfaces",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::InterfaceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/InterfaceDef:1.0"
-        )
-    )->base_interfaces (
-      base_interfaces,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_InterfaceDef::is_a  (
-    const char * interface_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Boolean _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::InterfaceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/InterfaceDef:1.0"
-        )
-    )->is_a (
-      interface_id,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::InterfaceDef::FullInterfaceDescription * POA_CORBA::_tao_thru_poa_collocated_InterfaceDef::describe_interface  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::InterfaceDef::FullInterfaceDescription_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "describe_interface",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::InterfaceDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/InterfaceDef:1.0"
-        )
-    )->describe_interface (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::AttributeDef_ptr POA_CORBA::_tao_thru_poa_collocated_InterfaceDef::create_attribute  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_value_box_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    CORBA::IDLType_ptr type,
-    CORBA::AttributeMode mode,
+    CORBA::TypeCode_ptr boxed_type,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::AttributeDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_attribute",
+      "create_value_box_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::InterfaceDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/InterfaceDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_attribute (
+    )->create_value_box_tc (
       id,
       name,
-      version,
-      type,
-      mode,
+      boxed_type,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::OperationDef_ptr POA_CORBA::_tao_thru_poa_collocated_InterfaceDef::create_operation  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_native_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    CORBA::IDLType_ptr result,
-    CORBA::OperationMode mode,
-    const CORBA::ParDescriptionSeq & params,
-    const CORBA::ExceptionDefSeq & exceptions,
-    const CORBA::ContextIdSeq & contexts,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::OperationDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_operation",
+      "create_native_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::InterfaceDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/InterfaceDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_operation (
+    )->create_native_tc (
       id,
       name,
-      version,
-      result,
-      mode,
-      params,
-      exceptions,
-      contexts,
       ACE_TRY_ENV
     );
 
 }
 
-
-
-class TAO_CORBA_ValueMemberDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:54 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_ValueMemberDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_ValueMemberDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37,  0,
-     37, 37,  0,  0, 10, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37,  0,  0,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37,  0, 15, 37, 37, 37, 37, 10, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37,
-#else
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37, 37, 37, 37, 37, 37,
-     37, 37, 37, 37, 37,  0, 37,  0, 37, 37,
-      0,  0, 10, 37, 37, 37, 37, 37, 37,  0,
-      0, 37, 37, 37, 37,  0, 15, 37, 37, 37,
-     37, 10, 37, 37, 37, 37, 37, 37,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_ValueMemberDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 20,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 36,
-      HASH_VALUE_RANGE = 33,
-      DUPLICATES = 7
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::ValueMemberDef::move_skel},
-      {"_is_a",  &POA_CORBA::ValueMemberDef::_is_a_skel},
-      {"_get_id", 	&POA_CORBA::ValueMemberDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::ValueMemberDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::ValueMemberDef::describe_skel},
-      {"_get_type", 	&POA_CORBA::ValueMemberDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::ValueMemberDef::_set_name_skel},
-      {"_get_name", 	&POA_CORBA::ValueMemberDef::_get_name_skel},
-      {"_get_access", 	&POA_CORBA::ValueMemberDef::_get_access_skel},
-      {"_set_access", 	&POA_CORBA::ValueMemberDef::_set_access_skel},
-      {"_get_version", 	&POA_CORBA::ValueMemberDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::ValueMemberDef::_set_version_skel},
-      {"_get_def_kind", 	&POA_CORBA::ValueMemberDef::_get_def_kind_skel},
-      {"_get_defined_in", 	&POA_CORBA::ValueMemberDef::_get_defined_in_skel},
-      {"destroy", 	&POA_CORBA::ValueMemberDef::destroy_skel},
-      {"_get_absolute_name", 	&POA_CORBA::ValueMemberDef::_get_absolute_name_skel},
-      {"_get_type_def", 	&POA_CORBA::ValueMemberDef::_get_type_def_skel},
-      {"_set_type_def", 	&POA_CORBA::ValueMemberDef::_set_type_def_skel},
-      {"_non_existent",  &POA_CORBA::ValueMemberDef::_non_existent_skel},
-      {"_get_containing_repository", 	&POA_CORBA::ValueMemberDef::_get_containing_repository_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-      -12,  -2, -14,  -2,   4,   5,  -1,  53,   8,  46,  -1, -47, -46,  16, 
-       -1,  17,  -1,  18,  19,  -9,  -3, -20,  -2, -38,  -6,  -2,  -1,  -1, 
-       22,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  23, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:54 */
-static TAO_CORBA_ValueMemberDef_Perfect_Hash_OpTable tao_CORBA_ValueMemberDef_optable;
-
-CORBA::ValueMemberDef_ptr _TAO_collocation_POA_CORBA_ValueMemberDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::ValueMemberDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_ValueMemberDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_ValueMemberDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_ValueMemberDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_ValueMemberDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_ValueMemberDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_ValueMemberDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::ValueMemberDef::ValueMemberDef (void)
-{
-  this->optable_ = &tao_CORBA_ValueMemberDef_optable;
-}
-
-// copy ctor
-POA_CORBA::ValueMemberDef::ValueMemberDef (const ValueMemberDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::ValueMemberDef::~ValueMemberDef (void)
-{
-}
-
-void POA_CORBA::ValueMemberDef::_get_type_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueMemberDef *_tao_impl = (POA_CORBA::ValueMemberDef *)_tao_object_reference;
-
-  CORBA::TypeCode_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->type (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueMemberDef::_get_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueMemberDef *_tao_impl = (POA_CORBA::ValueMemberDef *)_tao_object_reference;
-
-  CORBA::IDLType_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->type_def (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueMemberDef::_set_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueMemberDef *_tao_impl = (POA_CORBA::ValueMemberDef *)_tao_object_reference;
-
-  CORBA::IDLType_var type_def;
-  if (!(
-    (_tao_in >> type_def.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->type_def (
-        type_def.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueMemberDef::_get_access_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueMemberDef *_tao_impl = (POA_CORBA::ValueMemberDef *)_tao_object_reference;
-
-  CORBA::Visibility _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_access",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->access (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_access",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_access",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueMemberDef::_set_access_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueMemberDef *_tao_impl = (POA_CORBA::ValueMemberDef *)_tao_object_reference;
-
-  CORBA::Visibility access;
-  if (!(
-    (_tao_in >> access)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_access",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->access (
-        access,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_access",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_access",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueMemberDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueMemberDef *_tao_impl = (POA_CORBA::ValueMemberDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::ValueMemberDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::ValueMemberDef *_tao_impl = (POA_CORBA::ValueMemberDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::ValueMemberDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ValueMemberDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::ValueMemberDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/ValueMemberDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::ValueMemberDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::ValueMemberDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::ValueMemberDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/ValueMemberDef:1.0";
-}
-
-CORBA::ValueMemberDef*
-POA_CORBA::ValueMemberDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::ValueMemberDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::ValueMemberDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef::_tao_thru_poa_collocated_ValueMemberDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueMemberDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueMemberDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueMemberDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueMemberDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef::type  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_recursive_tc  (
+    const char * id,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
@@ -20652,3464 +3193,121 @@ CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef::type  (
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "type",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueMemberDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueMemberDef:1.0"
-        )
-    )->type (
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::IDLType_ptr POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef::type_def  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::IDLType_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueMemberDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueMemberDef:1.0"
-        )
-    )->type_def (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef::type_def  (
-    CORBA::IDLType_ptr type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueMemberDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueMemberDef:1.0"
-        )
-    )->type_def (
-      type_def,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::Visibility POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef::access  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Visibility _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "access",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueMemberDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueMemberDef:1.0"
-        )
-    )->access (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueMemberDef::access  (
-    CORBA::Visibility access,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "access",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueMemberDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueMemberDef:1.0"
-        )
-    )->access (
-      access,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-
-
-class TAO_CORBA_ValueDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:54 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_ValueDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_ValueDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86,  0,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86,  0,
-     86, 50, 35,  0, 86, 86, 86, 25, 86, 86,
-     86, 86, 86, 86, 86, 86, 86,  0,  0, 15,
-     86,  0, 86,  0, 86, 86, 86, 86, 86, 86,
-     86, 86, 20, 20, 86, 86, 86,  5,  5, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86,
-#else
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86, 86, 86, 86, 86, 86,
-     86, 86, 86, 86, 86,  0, 86,  0, 86, 50,
-     35,  0, 86, 86, 86, 25, 86, 86,  0,  0,
-     15, 86,  0, 86,  0, 20, 20, 86, 86, 86,
-      5,  5, 86, 86, 86, 86, 86, 86,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_ValueDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 49,
-      MIN_WORD_LENGTH = 4,
-      MAX_WORD_LENGTH = 26,
-      MIN_HASH_VALUE = 4,
-      MAX_HASH_VALUE = 85,
-      HASH_VALUE_RANGE = 82,
-      DUPLICATES = 14
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},
-      {"move", 	&POA_CORBA::ValueDef::move_skel},
-      {"_is_a",  &POA_CORBA::ValueDef::_is_a_skel},
-      {"lookup", 	&POA_CORBA::ValueDef::lookup_skel},
-      {"_get_name", 	&POA_CORBA::ValueDef::_get_name_skel},
-      {"_get_type", 	&POA_CORBA::ValueDef::_get_type_skel},
-      {"_set_name", 	&POA_CORBA::ValueDef::_set_name_skel},
-      {"lookup_name", 	&POA_CORBA::ValueDef::lookup_name_skel},
-      {"_get_is_custom", 	&POA_CORBA::ValueDef::_get_is_custom_skel},
-      {"_set_is_custom", 	&POA_CORBA::ValueDef::_set_is_custom_skel},
-      {"_get_base_value", 	&POA_CORBA::ValueDef::_get_base_value_skel},
-      {"_set_base_value", 	&POA_CORBA::ValueDef::_set_base_value_skel},
-      {"_get_absolute_name", 	&POA_CORBA::ValueDef::_get_absolute_name_skel},
-      {"_get_is_truncatable", 	&POA_CORBA::ValueDef::_get_is_truncatable_skel},
-      {"_set_is_truncatable", 	&POA_CORBA::ValueDef::_set_is_truncatable_skel},
-      {"_get_supported_interface", 	&POA_CORBA::ValueDef::_get_supported_interface_skel},
-      {"_set_supported_interface", 	&POA_CORBA::ValueDef::_set_supported_interface_skel},
-      {"_get_version", 	&POA_CORBA::ValueDef::_get_version_skel},
-      {"_set_version", 	&POA_CORBA::ValueDef::_set_version_skel},
-      {"is_a", 	&POA_CORBA::ValueDef::is_a_skel},
-      {"_get_defined_in", 	&POA_CORBA::ValueDef::_get_defined_in_skel},
-      {"_get_containing_repository", 	&POA_CORBA::ValueDef::_get_containing_repository_skel},
-      {"_non_existent",  &POA_CORBA::ValueDef::_non_existent_skel},
-      {"_get_is_abstract", 	&POA_CORBA::ValueDef::_get_is_abstract_skel},
-      {"_set_is_abstract", 	&POA_CORBA::ValueDef::_set_is_abstract_skel},
-      {"_get_initializers", 	&POA_CORBA::ValueDef::_get_initializers_skel},
-      {"_set_initializers", 	&POA_CORBA::ValueDef::_set_initializers_skel},
-      {"_get_id", 	&POA_CORBA::ValueDef::_get_id_skel},
-      {"_set_id", 	&POA_CORBA::ValueDef::_set_id_skel},
-      {"describe", 	&POA_CORBA::ValueDef::describe_skel},
-      {"_get_abstract_base_values", 	&POA_CORBA::ValueDef::_get_abstract_base_values_skel},
-      {"_set_abstract_base_values", 	&POA_CORBA::ValueDef::_set_abstract_base_values_skel},
-      {"destroy", 	&POA_CORBA::ValueDef::destroy_skel},
-      {"_get_def_kind", 	&POA_CORBA::ValueDef::_get_def_kind_skel},
-      {"describe_value", 	&POA_CORBA::ValueDef::describe_value_skel},
-      {"create_enum", 	&POA_CORBA::ValueDef::create_enum_skel},
-      {"create_value", 	&POA_CORBA::ValueDef::create_value_skel},
-      {"create_module", 	&POA_CORBA::ValueDef::create_module_skel},
-      {"create_attribute", 	&POA_CORBA::ValueDef::create_attribute_skel},
-      {"create_interface", 	&POA_CORBA::ValueDef::create_interface_skel},
-      {"create_value_member", 	&POA_CORBA::ValueDef::create_value_member_skel},
-      {"create_value_box", 	&POA_CORBA::ValueDef::create_value_box_skel},
-      {"describe_contents", 	&POA_CORBA::ValueDef::describe_contents_skel},
-      {"create_union", 	&POA_CORBA::ValueDef::create_union_skel},
-      {"contents", 	&POA_CORBA::ValueDef::contents_skel},
-      {"create_operation", 	&POA_CORBA::ValueDef::create_operation_skel},
-      {"create_exception", 	&POA_CORBA::ValueDef::create_exception_skel},
-      {"create_alias", 	&POA_CORBA::ValueDef::create_alias_skel},
-      {"create_struct", 	&POA_CORBA::ValueDef::create_struct_skel},
-      {"create_constant", 	&POA_CORBA::ValueDef::create_constant_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -7,  -3,   4,   5,   6, -11,  -2, -92,  -1,  10, -13,  -2, 
-      -92, -88, -16,  -2,  15, -88, -18,  -2, -20,  -2, -89, -26,  -2, -90, 
-       -1,  22,  23,  24,  -1,  25, -28,  -2, -96, -88, -30,  -2, -33,  -2, 
-      -89,  32,  -1, -90,  -1,  35,  36,  37,  -1,  -1,  -1,  -1,  -1,  -1, 
-       -1,  -1,  -1,  -1,  -1,  38,  39,  40, -41,  -2, -87,  -1,  -1,  43, 
-       -1,  44,  45,  -1,  -1,  -1,  -1,  46,  47, -48,  -2, -87,  50,  51, 
-       -1,  52, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:54 */
-static TAO_CORBA_ValueDef_Perfect_Hash_OpTable tao_CORBA_ValueDef_optable;
-
-CORBA::ValueDef_ptr _TAO_collocation_POA_CORBA_ValueDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::ValueDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_ValueDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_ValueDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_ValueDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_ValueDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_ValueDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_ValueDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_ValueDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::ValueDef::ValueDef (void)
-{
-  this->optable_ = &tao_CORBA_ValueDef_optable;
-}
-
-// copy ctor
-POA_CORBA::ValueDef::ValueDef (const ValueDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,Container) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,Contained) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::ValueDef::~ValueDef (void)
-{
-}
-
-void POA_CORBA::ValueDef::_get_supported_interface_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::InterfaceDef_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_supported_interface",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->supported_interface (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_supported_interface",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_supported_interface",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::_set_supported_interface_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::InterfaceDef_var supported_interface;
-  if (!(
-    (_tao_in >> supported_interface.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_supported_interface",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->supported_interface (
-        supported_interface.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_supported_interface",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_supported_interface",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueDef::_get_initializers_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::InitializerSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_initializers",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->initializers (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_initializers",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_initializers",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::_set_initializers_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::InitializerSeq initializers;
-  if (!(
-    (_tao_in >> initializers)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_initializers",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->initializers (
-        initializers,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_initializers",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_initializers",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueDef::_get_base_value_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::ValueDef_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_base_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->base_value (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_base_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_base_value",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::_set_base_value_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::ValueDef_var base_value;
-  if (!(
-    (_tao_in >> base_value.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_base_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->base_value (
-        base_value.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_base_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_base_value",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueDef::_get_abstract_base_values_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::ValueDefSeq_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_abstract_base_values",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->abstract_base_values (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_abstract_base_values",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_abstract_base_values",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::_set_abstract_base_values_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::ValueDefSeq abstract_base_values;
-  if (!(
-    (_tao_in >> abstract_base_values)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_abstract_base_values",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->abstract_base_values (
-        abstract_base_values,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_abstract_base_values",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_abstract_base_values",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueDef::_get_is_abstract_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::Boolean _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_is_abstract",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->is_abstract (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_is_abstract",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_is_abstract",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << CORBA::Any::from_boolean (_tao_retval))
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::_set_is_abstract_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::Boolean is_abstract;
-  if (!(
-    (_tao_in >> CORBA::Any::to_boolean (is_abstract))
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_is_abstract",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->is_abstract (
-        is_abstract,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_is_abstract",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_is_abstract",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueDef::_get_is_custom_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::Boolean _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_is_custom",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->is_custom (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_is_custom",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_is_custom",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << CORBA::Any::from_boolean (_tao_retval))
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::_set_is_custom_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::Boolean is_custom;
-  if (!(
-    (_tao_in >> CORBA::Any::to_boolean (is_custom))
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_is_custom",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->is_custom (
-        is_custom,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_is_custom",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_is_custom",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueDef::_get_is_truncatable_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::Boolean _tao_retval = 0;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_is_truncatable",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->is_truncatable (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_is_truncatable",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_is_truncatable",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << CORBA::Any::from_boolean (_tao_retval))
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::_set_is_truncatable_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::Boolean is_truncatable;
-  if (!(
-    (_tao_in >> CORBA::Any::to_boolean (is_truncatable))
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_is_truncatable",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->is_truncatable (
-        is_truncatable,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_is_truncatable",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_is_truncatable",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueDef::is_a_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value_id;
-  if (!(
-    (_tao_in >> value_id.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "is_a",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->is_a (
-        value_id.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "is_a",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "is_a",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << CORBA::Any::from_boolean (_tao_retval))
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::describe_value_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::ValueDef::FullValueDescription_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "describe_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->describe_value (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "describe_value",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "describe_value",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::create_value_member_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::ValueMemberDef_var _tao_retval;
-  CORBA::String_var id;
-  CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::IDLType_var type;
-  CORBA::Visibility access;
-  if (!(
-    (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> type.out ()) &&
-    (_tao_in >> access)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_value_member",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_value_member (
-        id.in (),
-        name.in (),
-        version.in (),
-        type.in (),
-        access,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_value_member",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_value_member",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::create_attribute_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::AttributeDef_var _tao_retval;
-  CORBA::String_var id;
-  CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::IDLType_var type;
-  CORBA::AttributeMode mode;
-  if (!(
-    (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> type.out ()) &&
-    (_tao_in >> mode)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_attribute",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_attribute (
-        id.in (),
-        name.in (),
-        version.in (),
-        type.in (),
-        mode,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_attribute",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_attribute",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::create_operation_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *)_tao_object_reference;
-
-  CORBA::OperationDef_var _tao_retval;
-  CORBA::String_var id;
-  CORBA::String_var name;
-  CORBA::String_var version;
-  CORBA::IDLType_var result;
-  CORBA::OperationMode mode;
-  CORBA::ParDescriptionSeq params;
-  CORBA::ExceptionDefSeq exceptions;
-  CORBA::ContextIdSeq contexts;
-  if (!(
-    (_tao_in >> id.out ()) &&
-    (_tao_in >> name.out ()) &&
-    (_tao_in >> version.out ()) &&
-    (_tao_in >> result.out ()) &&
-    (_tao_in >> mode) &&
-    (_tao_in >> params) &&
-    (_tao_in >> exceptions) &&
-    (_tao_in >> contexts)
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_operation",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->create_operation (
-        id.in (),
-        name.in (),
-        version.in (),
-        result.in (),
-        mode,
-        params,
-        exceptions,
-        contexts,
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_operation",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "create_operation",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::ValueDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::ValueDef *_tao_impl = (POA_CORBA::ValueDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::ValueDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ValueDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Container:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/Contained:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::ValueDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/ValueDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::ValueDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Container:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Container_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Contained:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::Contained_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::ValueDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::ValueDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/ValueDef:1.0";
-}
-
-CORBA::ValueDef*
-POA_CORBA::ValueDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::ValueDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_ValueDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::ValueDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_ValueDef::_tao_thru_poa_collocated_ValueDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Container) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_Contained) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::InterfaceDef_ptr POA_CORBA::_tao_thru_poa_collocated_ValueDef::supported_interface  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::InterfaceDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "supported_interface",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->supported_interface (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueDef::supported_interface  (
-    CORBA::InterfaceDef_ptr supported_interface,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "supported_interface",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->supported_interface (
-      supported_interface,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::InitializerSeq * POA_CORBA::_tao_thru_poa_collocated_ValueDef::initializers  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::InitializerSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "initializers",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->initializers (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueDef::initializers  (
-    const CORBA::InitializerSeq & initializers,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "initializers",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->initializers (
-      initializers,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::ValueDef_ptr POA_CORBA::_tao_thru_poa_collocated_ValueDef::base_value  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ValueDef_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "base_value",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->base_value (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueDef::base_value  (
-    CORBA::ValueDef_ptr base_value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "base_value",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->base_value (
-      base_value,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::ValueDefSeq * POA_CORBA::_tao_thru_poa_collocated_ValueDef::abstract_base_values  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ValueDefSeq_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "abstract_base_values",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->abstract_base_values (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueDef::abstract_base_values  (
-    const CORBA::ValueDefSeq & abstract_base_values,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "abstract_base_values",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->abstract_base_values (
-      abstract_base_values,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueDef::is_abstract  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Boolean _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "is_abstract",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->is_abstract (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueDef::is_abstract  (
-    CORBA::Boolean is_abstract,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "is_abstract",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->is_abstract (
-      is_abstract,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueDef::is_custom  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Boolean _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "is_custom",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->is_custom (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueDef::is_custom  (
-    CORBA::Boolean is_custom,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "is_custom",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->is_custom (
-      is_custom,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueDef::is_truncatable  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Boolean _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "is_truncatable",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->is_truncatable (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueDef::is_truncatable  (
-    CORBA::Boolean is_truncatable,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "is_truncatable",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->is_truncatable (
-      is_truncatable,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueDef::is_a  (
-    const char * value_id,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::Boolean _tao_retval = 0;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN  (_tao_retval);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
-        )
-    )->is_a (
-      value_id,
-      ACE_TRY_ENV
-    );
-
-}
-
-CORBA::ValueDef::FullValueDescription * POA_CORBA::_tao_thru_poa_collocated_ValueDef::describe_value  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::ValueDef::FullValueDescription_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "describe_value",
+      "create_recursive_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->describe_value (
+    )->create_recursive_tc (
+      id,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::ValueMemberDef_ptr POA_CORBA::_tao_thru_poa_collocated_ValueDef::create_value_member  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_abstract_interface_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    CORBA::IDLType_ptr type,
-    CORBA::Visibility access,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::ValueMemberDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_value_member",
+      "create_abstract_interface_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_value_member (
+    )->create_abstract_interface_tc (
       id,
       name,
-      version,
-      type,
-      access,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::AttributeDef_ptr POA_CORBA::_tao_thru_poa_collocated_ValueDef::create_attribute  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_component_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    CORBA::IDLType_ptr type,
-    CORBA::AttributeMode mode,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::AttributeDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_attribute",
+      "create_component_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_attribute (
+    )->create_component_tc (
       id,
       name,
-      version,
-      type,
-      mode,
       ACE_TRY_ENV
     );
 
 }
 
-CORBA::OperationDef_ptr POA_CORBA::_tao_thru_poa_collocated_ValueDef::create_operation  (
+CORBA::TypeCode_ptr POA_CORBA::_tao_thru_poa_collocated_TypeCodeFactory::create_home_tc  (
     const char * id,
     const char * name,
-    const char * version,
-    CORBA::IDLType_ptr result,
-    CORBA::OperationMode mode,
-    const CORBA::ParDescriptionSeq & params,
-    const CORBA::ExceptionDefSeq & exceptions,
-    const CORBA::ContextIdSeq & contexts,
     CORBA::Environment &ACE_TRY_ENV
   )
   ACE_THROW_SPEC ((
     CORBA::SystemException
   ))
 {
-  CORBA::OperationDef_var _tao_retval;
+  CORBA::TypeCode_var _tao_retval;
   ACE_UNUSED_ARG (_tao_retval);
   TAO_Object_Adapter::Servant_Upcall servant_upcall (
       *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
     );
   servant_upcall.prepare_for_upcall (
       this->_object_key (),
-      "create_operation",
+      "create_home_tc",
       ACE_TRY_ENV
     );
   ACE_CHECK_RETURN (0);
   return ACE_reinterpret_cast (
-      POA_CORBA::ValueDef_ptr,
+      POA_CORBA::TypeCodeFactory_ptr,
       servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueDef:1.0"
+          "IDL:omg.org/CORBA/TypeCodeFactory:1.0"
         )
-    )->create_operation (
+    )->create_home_tc (
       id,
       name,
-      version,
-      result,
-      mode,
-      params,
-      exceptions,
-      contexts,
       ACE_TRY_ENV
     );
 
 }
 
-
-
-class TAO_CORBA_ValueBoxDef_Perfect_Hash_OpTable : public TAO_Perfect_Hash_OpTable
-{
-private:
-  unsigned int hash (const char *str, unsigned int len);
-public:
- const TAO_operation_db_entry * lookup (const char *str, unsigned int len);
-};
-/* starting time is 22:05:54 */
-/* C++ code produced by gperf version 2.8 (ACE version) */
-/* Command-line: gperf -m -M -J -c -C -D -E -T -f 0 -F 0 -a -o -t -p -K opname_ -L C++ -Z TAO_CORBA_ValueBoxDef_Perfect_Hash_OpTable -N lookup  */
-unsigned int
-TAO_CORBA_ValueBoxDef_Perfect_Hash_OpTable::hash (const char *str, unsigned int len)
-{
-  static const unsigned char asso_values[] =
-    {
-#if defined (ACE_MVS)
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23,  0,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23,  0,
-     23, 23,  0,  0,  0, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23,  5, 23, 23, 23, 23,  0, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23,
-#else
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23,  0, 23,  0, 23, 23,
-      0,  0,  0, 23, 23, 23, 23, 23, 23, 23,
-     23, 23, 23, 23, 23, 23,  5, 23, 23, 23,
-     23,  0, 23, 23, 23, 23, 23, 23,
-#endif /* ACE_MVS */
-    };
-  return len + asso_values[str[len - 1]] + asso_values[str[0]];
-}
-
-const class TAO_operation_db_entry *
-TAO_CORBA_ValueBoxDef_Perfect_Hash_OpTable::lookup (const char *str, unsigned int len)
-{
-  enum
-    {
-      TOTAL_KEYWORDS = 7,
-      MIN_WORD_LENGTH = 5,
-      MAX_WORD_LENGTH = 22,
-      MIN_HASH_VALUE = 5,
-      MAX_HASH_VALUE = 22,
-      HASH_VALUE_RANGE = 18,
-      DUPLICATES = 2
-    };
-
-  static const class TAO_operation_db_entry  wordlist[] =
-    {
-      {"",0},{"",0},{"",0},{"",0},{"",0},
-      {"_is_a",  &POA_CORBA::ValueBoxDef::_is_a_skel},
-      {"destroy", 	&POA_CORBA::ValueBoxDef::destroy_skel},
-      {"_get_type", 	&POA_CORBA::ValueBoxDef::_get_type_skel},
-      {"_get_def_kind", 	&POA_CORBA::ValueBoxDef::_get_def_kind_skel},
-      {"_non_existent",  &POA_CORBA::ValueBoxDef::_non_existent_skel},
-      {"_get_original_type_def", 	&POA_CORBA::ValueBoxDef::_get_original_type_def_skel},
-      {"_set_original_type_def", 	&POA_CORBA::ValueBoxDef::_set_original_type_def_skel},
-    };
-
-  static const signed char lookup[] =
-    {
-       -1,  -1,  -1,  -1,  -1,   5,  -1,   6,  -1,   7,  -1,  -1,  -1,   8, 
-       -1,  -1,  -1,  -1,   9,  -1, -10,  -2, -24, 
-    };
-
-  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
-    {
-      unsigned int key = hash (str, len);
-
-      if (key <= MAX_HASH_VALUE && key >= MIN_HASH_VALUE)
-        {
-          int slot = lookup[key];
-
-          if (slot >= 0 && slot < MAX_HASH_VALUE)
-            {
-              const char *s = wordlist[slot].opname_;
-
-              if (*str == *s && !strncmp (str + 1, s + 1, len - 1))
-                return &wordlist[slot];
-            }
-          else if (slot < 0 && slot >= -MAX_HASH_VALUE)
-            return 0;
-          else
-            {
-              unsigned int offset = key + slot + (slot > 0 ? -MAX_HASH_VALUE : MAX_HASH_VALUE);
-              const class TAO_operation_db_entry  *base = &wordlist[-lookup[offset]];
-              const class TAO_operation_db_entry  *ptr = base + -lookup[offset + 1];
-
-              while (--ptr >= base)
-                if (*str == *ptr->opname_ && !strncmp (str + 1, ptr->opname_ + 1, len - 1))
-                  return ptr;
-            }
-        }
-    }
-  return 0;
-}
-/* ending time is 22:05:54 */
-static TAO_CORBA_ValueBoxDef_Perfect_Hash_OpTable tao_CORBA_ValueBoxDef_optable;
-
-CORBA::ValueBoxDef_ptr _TAO_collocation_POA_CORBA_ValueBoxDef_Stub_Factory (
-    CORBA::Object_ptr obj
-  )
-{
-  TAO_Stub *stub = obj->_stubobj ();
-  
-  switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-    {
-    case TAO_ORB_Core::THRU_POA:
-      {
-      CORBA::ValueBoxDef_ptr retval = 0;
-      ACE_NEW_RETURN (
-          retval,
-          POA_CORBA::_tao_thru_poa_collocated_ValueBoxDef (stub),
-          0
-        );
-      return retval;
-      }
-    case TAO_ORB_Core::DIRECT:
-      break;
-    default:
-      break;
-    }
-  return 0;
-}
-
-int _TAO_collocation_POA_CORBA_ValueBoxDef_Stub_Factory_Initializer (long dummy)
-{
-  ACE_UNUSED_ARG (dummy);
-  
-  _TAO_collocation_CORBA_ValueBoxDef_Stub_Factory_function_pointer = 
-    _TAO_collocation_POA_CORBA_ValueBoxDef_Stub_Factory;
-  
-  return 0;
-}
-
-static int _TAO_collocation_POA_CORBA_ValueBoxDef_Stub_Factory_Initializer_Scarecrow = 
-  _TAO_collocation_POA_CORBA_ValueBoxDef_Stub_Factory_Initializer (ACE_reinterpret_cast (long, _TAO_collocation_POA_CORBA_ValueBoxDef_Stub_Factory_Initializer));
-
-// skeleton constructor
-POA_CORBA::ValueBoxDef::ValueBoxDef (void)
-{
-  this->optable_ = &tao_CORBA_ValueBoxDef_optable;
-}
-
-// copy ctor
-POA_CORBA::ValueBoxDef::ValueBoxDef (const ValueBoxDef& rhs)
-  :   ACE_NESTED_CLASS (POA_CORBA,IDLType) (rhs),
-    ACE_NESTED_CLASS (POA_CORBA,IRObject) (rhs),
-    TAO_ServantBase (rhs)
-{}
-
-// skeleton destructor
-POA_CORBA::ValueBoxDef::~ValueBoxDef (void)
-{
-}
-
-void POA_CORBA::ValueBoxDef::_get_original_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  POA_CORBA::ValueBoxDef *_tao_impl = (POA_CORBA::ValueBoxDef *)_tao_object_reference;
-
-  CORBA::IDLType_var _tao_retval;
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_original_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_retval = _tao_impl->original_type_def (
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_original_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_get_original_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!(
-    (_tao_out << _tao_retval.in ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-}
-
-void POA_CORBA::ValueBoxDef::_set_original_type_def_skel (
-    CORBA::ServerRequest &_tao_server_request,
-    void *_tao_object_reference, 
-    void * /* context */, 
-    CORBA::Environment &ACE_TRY_ENV
-)
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueBoxDef *_tao_impl = (POA_CORBA::ValueBoxDef *)_tao_object_reference;
-
-  CORBA::IDLType_var original_type_def;
-  if (!(
-    (_tao_in >> original_type_def.out ())
-  ))
-    ACE_THROW (CORBA::MARSHAL () );
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-  TAO_ServerRequestInterceptor_Adapter
-    _tao_vfr (_tao_server_request.orb ()->_get_server_interceptor (ACE_TRY_ENV));
-  ACE_CHECK;
-  PortableInterceptor::Cookies _tao_cookies;
-  CORBA::NVList_var _tao_interceptor_args;
-  CORBA::Object_var _tao_objref;
-  if (_tao_vfr.valid ())
-    {
-      _tao_server_request.orb ()->create_list (0, _tao_interceptor_args.inout (), ACE_TRY_ENV);
-      ACE_CHECK;
-
-      _tao_objref = _tao_server_request.objref (ACE_TRY_ENV);
-      ACE_CHECK;
-    }
-
-  ACE_TRY
-    {
-      _tao_vfr.preinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_original_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-      _tao_impl->original_type_def (
-        original_type_def.in (),
-        ACE_TRY_ENV
-      );
-
-      TAO_INTERCEPTOR_CHECK;
-
-#if (TAO_HAS_INTERCEPTORS == 1)
-      _tao_vfr.postinvoke (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_original_type_def",
-          _tao_server_request.service_info (),
-          _tao_interceptor_args.inout (),
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      TAO_INTERCEPTOR_CHECK;
-    }
-  ACE_CATCHANY
-    {
-      _tao_vfr.exception_occurred (
-          _tao_server_request.request_id (),
-          1,
-          _tao_objref.in (),
-          "_set_original_type_def",
-          _tao_cookies,
-          ACE_TRY_ENV
-        );
-      ACE_RETHROW;
-    }
-  ACE_ENDTRY;
-  ACE_CHECK;
-#endif /* TAO_HAS_INTERCEPTORS */
-
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  }
-
-void POA_CORBA::ValueBoxDef::_is_a_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  TAO_InputCDR &_tao_in = _tao_server_request.incoming ();
-  POA_CORBA::ValueBoxDef *_tao_impl = (POA_CORBA::ValueBoxDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = 0;
-  CORBA::String_var value;
-  if (!((_tao_in >> value.out ())))
-    ACE_THROW (CORBA::MARSHAL ());
-  
-  _tao_retval = _tao_impl->_is_a (value.in (), ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-void POA_CORBA::ValueBoxDef::_non_existent_skel (
-    CORBA::ServerRequest &_tao_server_request, 
-    void * _tao_object_reference,
-    void * /* context */,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  POA_CORBA::ValueBoxDef *_tao_impl = (POA_CORBA::ValueBoxDef *) _tao_object_reference;
-  CORBA::Boolean _tao_retval = _tao_impl->_non_existent (ACE_TRY_ENV);
-  ACE_CHECK;
-  
-  _tao_server_request.init_reply (ACE_TRY_ENV);
-  ACE_CHECK;
-  TAO_OutputCDR &_tao_out = _tao_server_request.outgoing ();
-  if (!((_tao_out << CORBA::Any::from_boolean (_tao_retval))))
-    ACE_THROW (CORBA::MARSHAL ());
-}
-
-CORBA::Boolean POA_CORBA::ValueBoxDef::_is_a (
-    const char* value,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-{
-  if (
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/ValueBoxDef:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IDLType:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, "IDL:omg.org/CORBA/IRObject:1.0")) ||
-    (!ACE_OS::strcmp ((char *)value, CORBA::_tc_Object->id (ACE_TRY_ENV))))
-      return 1;
-    else
-      return 0;
-}
-
-void* POA_CORBA::ValueBoxDef::_downcast (
-    const char* logical_type_id
-  )
-{
-if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/ValueBoxDef:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::ValueBoxDef_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IDLType:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IDLType_ptr, this);
-  if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/IRObject:1.0") == 0)
-    return ACE_static_cast (POA_CORBA::IRObject_ptr, this);
-    if (ACE_OS::strcmp (logical_type_id, "IDL:omg.org/CORBA/Object:1.0") == 0)
-    return ACE_static_cast(PortableServer::Servant, this);
-  return 0;
-}
-
-void POA_CORBA::ValueBoxDef::_dispatch (CORBA::ServerRequest &req, void *context, CORBA::Environment &ACE_TRY_ENV)
-{
-  TAO_Skeleton skel; // pointer to skeleton for operation
-  const char *opname = req.operation (); // retrieve operation name
-  // find the skeleton corresponding to this opname
-  if (this->_find (opname, skel, req.operation_length ()) == -1)
-  {
-    ACE_ERROR ((LM_ERROR, "Bad operation <%s>\n", opname));
-    ACE_THROW (CORBA_BAD_OPERATION ());
-  }
-  else
-    skel (req, this, context, ACE_TRY_ENV);
-}
-
-const char* POA_CORBA::ValueBoxDef::_interface_repository_id (void) const
-{
-  return "IDL:omg.org/CORBA/ValueBoxDef:1.0";
-}
-
-CORBA::ValueBoxDef*
-POA_CORBA::ValueBoxDef::_this (CORBA_Environment &ACE_TRY_ENV)
-{
-  TAO_Stub *stub = this->_create_stub (ACE_TRY_ENV);
-  ACE_CHECK_RETURN (0);
-  if (stub->servant_orb_var ()->orb_core ()->optimize_collocation_objects ())
-    switch (stub->servant_orb_var ()->orb_core ()->get_collocation_strategy ())
-      {
-      case TAO_ORB_Core::THRU_POA:
-        {
-          ::CORBA::ValueBoxDef_ptr retval = 0;
-          ACE_NEW_RETURN (
-              retval,
-              POA_CORBA::_tao_thru_poa_collocated_ValueBoxDef (stub),
-              0
-            );
-          return retval;
-        }
-      case TAO_ORB_Core::DIRECT:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      default:
-        ACE_THROW_RETURN (CORBA::BAD_PARAM (), 0);
-      }
-  else
-    {
-      // stub->_incr_refcnt ();
-      CORBA::Object_ptr tmp = CORBA::Object::_nil ();
-      ACE_NEW_RETURN (tmp, CORBA::Object (stub), 0);
-      CORBA::Object_var obj = tmp;
-      return ::CORBA::ValueBoxDef::_unchecked_narrow (obj.in ());
-    }
-}
-
-POA_CORBA::_tao_thru_poa_collocated_ValueBoxDef::_tao_thru_poa_collocated_ValueBoxDef (
-  TAO_Stub *stub
-)
-  :  ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IDLType) (stub),
-    ACE_NESTED_CLASS (POA_CORBA,_tao_thru_poa_collocated_IRObject) (stub),
-    CORBA_Object (stub, 0, 1)
-{
-}
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueBoxDef::_is_a(
-    const CORBA::Char *logical_type_id,
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_is_a",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueBoxDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueBoxDef:1.0"
-        )
-    )->_is_a (logical_type_id, ACE_TRY_ENV);
-}
-
-
-CORBA::Boolean POA_CORBA::_tao_thru_poa_collocated_ValueBoxDef::_non_existent(
-    CORBA_Environment &ACE_TRY_ENV
-  )
-
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "_non_existent",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueBoxDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueBoxDef:1.0"
-        )
-    )->_non_existent (ACE_TRY_ENV);
-}
-
-
-CORBA::IDLType_ptr POA_CORBA::_tao_thru_poa_collocated_ValueBoxDef::original_type_def  (
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  CORBA::IDLType_var _tao_retval;
-  ACE_UNUSED_ARG (_tao_retval);
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "original_type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK_RETURN (0);
-  return ACE_reinterpret_cast (
-      POA_CORBA::ValueBoxDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueBoxDef:1.0"
-        )
-    )->original_type_def (
-      ACE_TRY_ENV
-    );
-
-}
-
-void POA_CORBA::_tao_thru_poa_collocated_ValueBoxDef::original_type_def  (
-    CORBA::IDLType_ptr original_type_def,
-    CORBA::Environment &ACE_TRY_ENV
-  )
-  ACE_THROW_SPEC ((
-    CORBA::SystemException
-  ))
-{
-  TAO_Object_Adapter::Servant_Upcall servant_upcall (
-      *this->_stubobj ()->servant_orb_var ()->orb_core ()->object_adapter ()
-    );
-  servant_upcall.prepare_for_upcall (
-      this->_object_key (),
-      "original_type_def",
-      ACE_TRY_ENV
-    );
-  ACE_CHECK;
-  ACE_reinterpret_cast (
-      POA_CORBA::ValueBoxDef_ptr,
-      servant_upcall.servant ()->_downcast (
-          "IDL:omg.org/CORBA/ValueBoxDef:1.0"
-        )
-    )->original_type_def (
-      original_type_def,
-      ACE_TRY_ENV
-    );
-  return;
-}
-
 #endif /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
 
 
diff --git a/TAO/tao/InterfaceS.h b/TAO/tao/InterfaceS.h
index 9acdaff3d7a..cfd6d0dbca1 100644
--- a/TAO/tao/InterfaceS.h
+++ b/TAO/tao/InterfaceS.h
@@ -33,10 +33,6 @@
 #pragma warning(disable:4250)
 #endif /* _MSC_VER */
 
-#if defined (__ACE_INLINE__)
-#include "tao/InterfaceS.i"
-#endif /* defined INLINE */
-
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 #pragma warning(pop)
 #endif /* _MSC_VER */
diff --git a/TAO/tao/ORB.cpp b/TAO/tao/ORB.cpp
index f5bfbee44c9..e4e00c27767 100644
--- a/TAO/tao/ORB.cpp
+++ b/TAO/tao/ORB.cpp
@@ -32,10 +32,6 @@
 #include "tao/Request.h"
 #include "tao/MProfile.h"
 
-#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
-#  include "tao/InterfaceC.h"
-#endif /*TAO_HAS_INTERFACE_REPOSITORY */
-
 #if defined (TAO_HAS_VALUETYPE)
 #  include "tao/ValueFactory_Map.h"
 #endif /* TAO_HAS_VALUETYPE */
diff --git a/TAO/tao/ORB.h b/TAO/tao/ORB.h
index 0b86fd31c0a..af232c8b2b5 100644
--- a/TAO/tao/ORB.h
+++ b/TAO/tao/ORB.h
@@ -39,6 +39,10 @@
 // IRIX needs this for the throw specs
 #include "tao/PolicyC.h"
 
+#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
+#  include "tao/InterfaceC.h"
+#endif /*TAO_HAS_INTERFACE_REPOSITORY */
+
 // For the (W)String_var and (W)String_out iostream operators.
 #if defined (ACE_HAS_MINIMUM_IOSTREAMH_INCLUSION)
 #include "ace/streams.h"
@@ -379,7 +383,7 @@ public:
              TAO_default_environment () );
 #endif /* TAO_HAS_VALUETYPE */
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   // = Interceptor registration routine
   //   Currently, we only support one interceptor per-ORB.
 
@@ -404,7 +408,7 @@ public:
   // accessor to the server-side interceptor.  You get a duplicate.
 #endif /* TAO_HAS_INTERCEPTORS */
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if !defined (TAO_HAS_MINIMUM_CORBA)
 
   // Typedefs for CORBA_ORB_RequestSeq,
   // which is an argument of send_multiple_requests_*().
@@ -494,21 +498,24 @@ public:
                                                CORBA::Environment &ACE_TRY_ENV
                                                = TAO_default_environment ());
 
+
 #if (TAO_HAS_INTERFACE_REPOSITORY == 1)
+
   //Methods added for Philipe Merle for CORBA Script..
+
   CORBA_TypeCode_ptr create_interface_tc (const char * id,
                                           const char * name,
                                           CORBA::Environment &ACE_TRY_ENV =
                                           TAO_default_environment ());
   CORBA_TypeCode_ptr create_enum_tc (const char *id,
                                      const char *name,
-                                     CORBA_EnumMemberSeq &members,
+                                     IR::EnumMemberSeq &members,
                                      CORBA::Environment &ACE_TRY_ENV =
                                      TAO_default_environment ());
 
   CORBA_TypeCode_ptr create_exception_tc (const char *id,
                                           const char *name,
-                                          CORBA_StructMemberSeq &members,
+                                          IR::StructMemberSeq &members,
                                           CORBA::Environment &ACE_TRY_ENV =
                                           TAO_default_environment ());
 
@@ -520,12 +527,11 @@ public:
 
   CORBA_TypeCode_ptr create_struct_tc (const char *id,
                                        const char *name,
-                                       CORBA_StructMemberSeq &members,
+                                       IR::StructMemberSeq &members,
                                        CORBA::Environment &ACE_TRY_ENV =
                                        TAO_default_environment ());
 
-
-#endif /*TAO_HAS_INTERFACE_REPOSITORY */
+#endif /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
 
 #endif /* TAO_HAS_MINIMUM_CORBA */
 
@@ -803,7 +809,7 @@ private:
   // If non-0 then this is the Factory for OBV unmarshaling
 #endif /* TAO_HAS_VALUETYPE */
 
-#if (TAO_HAS_INTERCEPTORS == 1)
+#if defined (TAO_HAS_INTERCEPTORS)
   PortableInterceptor::ClientRequestInterceptor_var client_interceptor_;
   PortableInterceptor::ServerRequestInterceptor_var server_interceptor_;
   // Interceptor registries.
diff --git a/TAO/tao/Object.cpp b/TAO/tao/Object.cpp
index 5bd3372df1e..41f9149aa42 100644
--- a/TAO/tao/Object.cpp
+++ b/TAO/tao/Object.cpp
@@ -248,7 +248,7 @@ CORBA::Object::_use_locate_requests (CORBA::Boolean use_it)
   return;
 }
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if !defined (TAO_HAS_MINIMUM_CORBA)
 
 // NON_EXISTENT ... send a simple call to the object, which will
 // either elicit a FALSE response or a OBJECT_NOT_EXIST exception.  In
@@ -422,14 +422,12 @@ CORBA_Object::_request (const CORBA::Char *operation,
       ACE_THROW_RETURN (CORBA::NO_IMPLEMENT (), CORBA::Request::_nil ());
 }
 
-CORBA::InterfaceDef_ptr
+#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
+
+IR::InterfaceDef_ptr
 CORBA_Object::_get_interface (CORBA::Environment &ACE_TRY_ENV)
 {
-#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
-  CORBA::InterfaceDef_ptr _tao_retval = CORBA::InterfaceDef::_nil();
-#else
-  CORBA::InterfaceDef_ptr _tao_retval = 0;
-#endif  /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
+  IR::InterfaceDef_ptr _tao_retval = IR::InterfaceDef::_nil();
 
   TAO_Stub *istub = this->_stubobj ();
   if (istub == 0)
@@ -471,7 +469,6 @@ CORBA_Object::_get_interface (CORBA::Environment &ACE_TRY_ENV)
       break;
     }
 
-#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
   TAO_InputCDR &_tao_in = _tao_call.inp_stream ();
   if (!(
         (_tao_in >> _tao_retval)
@@ -479,12 +476,10 @@ CORBA_Object::_get_interface (CORBA::Environment &ACE_TRY_ENV)
     ACE_THROW_RETURN (CORBA::MARSHAL (), _tao_retval);
 
   return _tao_retval;
-#else
-  ACE_UNUSED_ARG (_tao_retval);
-  ACE_THROW_RETURN (CORBA::INTF_REPOS (), _tao_retval);
-#endif  /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
 }
 
+#endif  /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
+
 CORBA::ImplementationDef_ptr
 CORBA_Object::_get_implementation (CORBA::Environment &)
 {
@@ -566,7 +561,7 @@ CORBA_Object::_validate_connection (CORBA::PolicyList_out inconsistent_policies,
 {
   inconsistent_policies = 0;
 
-#if (TAO_HAS_MINIMUM_CORBA == 1)
+#if defined (TAO_HAS_MINIMUM_CORBA)
 
   ACE_UNUSED_ARG (ACE_TRY_ENV);
 
diff --git a/TAO/tao/Object.h b/TAO/tao/Object.h
index 0bf684025b0..b0c1fbaf336 100644
--- a/TAO/tao/Object.h
+++ b/TAO/tao/Object.h
@@ -32,6 +32,12 @@
 # pragma once
 #endif /* ACE_LACKS_PRAGMA_ONCE */
 
+#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
+  TAO_NAMESPACE_BEGIN (IR)
+  class InterfaceDef;
+  TAO_NAMESPACE_END
+#endif  /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
+
 class TAO_ServantBase;
 class TAO_Stub;
 
@@ -79,7 +85,7 @@ public:
   virtual CORBA::Boolean _is_collocated (void) const;
   // are we collocated with the servant?
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if !defined (TAO_HAS_MINIMUM_CORBA)
 
   virtual CORBA::Boolean _non_existent (CORBA_Environment &ACE_TRY_ENV =
                                           TAO_default_environment ());
@@ -90,8 +96,12 @@ public:
   // This method is deprecated in the CORBA 2.2 spec, we just return 0
   // every time.
 
-  virtual CORBA::InterfaceDef_ptr _get_interface (CORBA_Environment &ACE_TRY_ENV =
-                                                    TAO_default_environment ());
+#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
+
+  virtual IR::InterfaceDef *_get_interface (CORBA_Environment &ACE_TRY_ENV =
+                                                 TAO_default_environment ());
+
+#endif  /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
 
   // Interface repository related operations.
 
diff --git a/TAO/tao/POA_CORBA.h b/TAO/tao/POA_CORBA.h
index 18f77121f07..33f0788e7a6 100644
--- a/TAO/tao/POA_CORBA.h
+++ b/TAO/tao/POA_CORBA.h
@@ -773,7 +773,7 @@ public:
 
   // ****************************************************************
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if !defined (TAO_HAS_MINIMUM_CORBA)
 
   class DynAny;
   typedef DynAny *DynAny_ptr;
@@ -1863,7 +1863,7 @@ public:
 
     virtual const char* _interface_repository_id (void) const;
 
-    virtual CORBA::DefinitionKind def_kind (
+    virtual IR::DefinitionKind def_kind (
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -1911,7 +1911,7 @@ public:
         CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
       );
     
-        virtual CORBA::DefinitionKind def_kind (
+        virtual IR::DefinitionKind def_kind (
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -1928,16 +1928,17 @@ public:
       ));
   };
 
-  class Contained;
-  typedef Contained *Contained_ptr;
-  class TAO_Export Contained : public virtual IRObject
+  class TypeCodeFactory;
+  typedef TypeCodeFactory *TypeCodeFactory_ptr;
+  class  TypeCodeFactory :  public virtual PortableServer::ServantBase
   {
   protected:
-    Contained (void);
+    TypeCodeFactory (void);
 
   public:
-    Contained (const Contained& rhs);
-    virtual ~Contained (void);
+    TypeCodeFactory (const TypeCodeFactory& rhs);
+    virtual ~TypeCodeFactory (void);
+
 
     virtual CORBA::Boolean _is_a (
         const char* logical_type_id,
@@ -1972,64 +1973,17 @@ public:
           TAO_default_environment ()
       );
 
-    ::CORBA::Contained *_this (
+    ::CORBA::TypeCodeFactory *_this (
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       );
 
     virtual const char* _interface_repository_id (void) const;
 
-    virtual char * id (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void id (
+    virtual CORBA::TypeCode_ptr create_struct_tc (
         const char * id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual char * name (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void name (
         const char * name,
+        const IR::StructMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2037,7 +1991,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void _set_name_skel (
+    static void create_struct_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2045,72 +1999,11 @@ public:
           TAO_default_environment ()
       );
 
-    virtual char * version (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void version (
-        const char * version,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Container_ptr defined_in (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual char * absolute_name (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Repository_ptr containing_repository (
+    virtual CORBA::TypeCode_ptr create_union_tc (
+        const char * id,
+        const char * name,
+        CORBA::TypeCode_ptr discriminator_type,
+        const IR::UnionMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2118,7 +2011,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void _get_containing_repository_skel (
+    static void create_union_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2126,7 +2019,10 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::Contained::Description * describe (
+    virtual CORBA::TypeCode_ptr create_enum_tc (
+        const char * id,
+        const char * name,
+        const IR::EnumMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2134,7 +2030,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void describe_skel (
+    static void create_enum_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2142,10 +2038,10 @@ public:
           TAO_default_environment ()
       );
 
-    virtual void move (
-        CORBA::Container_ptr new_container,
-        const char * new_name,
-        const char * new_version,
+    virtual CORBA::TypeCode_ptr create_alias_tc (
+        const char * id,
+        const char * name,
+        CORBA::TypeCode_ptr original_type,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2153,7 +2049,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void move_skel (
+    static void create_alias_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2161,187 +2057,10 @@ public:
           TAO_default_environment ()
       );
 
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_Contained : public virtual ::CORBA::Contained,
-      public virtual _tao_thru_poa_collocated_IRObject
-  {
-  public:
-    _tao_thru_poa_collocated_Contained (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual char * id (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void id (
+    virtual CORBA::TypeCode_ptr create_exception_tc (
         const char * id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual char * name (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void name (
         const char * name,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual char * version (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void version (
-        const char * version,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Container_ptr defined_in (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual char * absolute_name (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Repository_ptr containing_repository (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Contained::Description * describe (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void move (
-        CORBA::Container_ptr new_container,
-        const char * new_name,
-        const char * new_version,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class Container;
-  typedef Container *Container_ptr;
-  class TAO_Export Container : public virtual IRObject
-  {
-  protected:
-    Container (void);
-
-  public:
-    Container (const Container& rhs);
-    virtual ~Container (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::Container *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::Contained_ptr lookup (
-        const char * search_name,
+        const IR::StructMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2349,7 +2068,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void lookup_skel (
+    static void create_exception_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2357,9 +2076,9 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::ContainedSeq * contents (
-        CORBA::DefinitionKind limit_type,
-        CORBA::Boolean exclude_inherited,
+    virtual CORBA::TypeCode_ptr create_interface_tc (
+        const char * id,
+        const char * name,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2367,7 +2086,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void contents_skel (
+    static void create_interface_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2375,11 +2094,8 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::ContainedSeq * lookup_name (
-        const char * search_name,
-        CORBA::Long levels_to_search,
-        CORBA::DefinitionKind limit_type,
-        CORBA::Boolean exclude_inherited,
+    virtual CORBA::TypeCode_ptr create_string_tc (
+        CORBA::ULong bound,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2387,7 +2103,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void lookup_name_skel (
+    static void create_string_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2395,10 +2111,8 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::Container::DescriptionSeq * describe_contents (
-        CORBA::DefinitionKind limit_type,
-        CORBA::Boolean exclude_inherited,
-        CORBA::Long max_returned_objs,
+    virtual CORBA::TypeCode_ptr create_wstring_tc (
+        CORBA::ULong bound,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2406,7 +2120,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void describe_contents_skel (
+    static void create_wstring_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2414,10 +2128,9 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::ModuleDef_ptr create_module (
-        const char * id,
-        const char * name,
-        const char * version,
+    virtual CORBA::TypeCode_ptr create_fixed_tc (
+        CORBA::UShort digits,
+        CORBA::UShort scale,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2425,7 +2138,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_module_skel (
+    static void create_fixed_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2433,12 +2146,9 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::ConstantDef_ptr create_constant (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA::IDLType_ptr type,
-        const CORBA::Any & value,
+    virtual CORBA::TypeCode_ptr create_sequence_tc (
+        CORBA::ULong bound,
+        CORBA::TypeCode_ptr element_type,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2446,7 +2156,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_constant_skel (
+    static void create_sequence_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2454,11 +2164,9 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::StructDef_ptr create_struct (
-        const char * id,
-        const char * name,
-        const char * version,
-        const CORBA::StructMemberSeq & members,
+    virtual CORBA::TypeCode_ptr create_array_tc (
+        CORBA::ULong length,
+        CORBA::TypeCode_ptr element_type,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2466,7 +2174,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_struct_skel (
+    static void create_array_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2474,12 +2182,12 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::UnionDef_ptr create_union (
+    virtual CORBA::TypeCode_ptr create_value_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr discriminator_type,
-        const CORBA::UnionMemberSeq & members,
+        CORBA::ValueModifier type_modifier,
+        CORBA::TypeCode_ptr concrete_base,
+        const IR::ValueMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2487,7 +2195,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_union_skel (
+    static void create_value_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2495,11 +2203,10 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::EnumDef_ptr create_enum (
+    virtual CORBA::TypeCode_ptr create_value_box_tc (
         const char * id,
         const char * name,
-        const char * version,
-        const CORBA::EnumMemberSeq & members,
+        CORBA::TypeCode_ptr boxed_type,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2507,7 +2214,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_enum_skel (
+    static void create_value_box_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2515,11 +2222,9 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::AliasDef_ptr create_alias (
+    virtual CORBA::TypeCode_ptr create_native_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr original_type,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2527,7 +2232,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_alias_skel (
+    static void create_native_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2535,11 +2240,8 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::InterfaceDef_ptr create_interface (
+    virtual CORBA::TypeCode_ptr create_recursive_tc (
         const char * id,
-        const char * name,
-        const char * version,
-        const CORBA::InterfaceDefSeq & base_interfaces,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2547,7 +2249,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_interface_skel (
+    static void create_recursive_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2555,17 +2257,9 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::ValueDef_ptr create_value (
+    virtual CORBA::TypeCode_ptr create_abstract_interface_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::Boolean is_custom,
-        CORBA::Boolean is_abstract,
-        CORBA::ValueDef_ptr base_value,
-        CORBA::Boolean is_truncatable,
-        const CORBA::ValueDefSeq & abstract_base_values,
-        CORBA::InterfaceDef_ptr supported_interface,
-        const CORBA::InitializerSeq & initializers,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2573,7 +2267,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_value_skel (
+    static void create_abstract_interface_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2581,11 +2275,9 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::ValueBoxDef_ptr create_value_box (
+    virtual CORBA::TypeCode_ptr create_component_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr original_type_def,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2593,7 +2285,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_value_box_skel (
+    static void create_component_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2601,11 +2293,9 @@ public:
           TAO_default_environment ()
       );
 
-    virtual CORBA::ExceptionDef_ptr create_exception (
+    virtual CORBA::TypeCode_ptr create_home_tc (
         const char * id,
         const char * name,
-        const char * version,
-        const CORBA::StructMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2613,7 +2303,7 @@ public:
         CORBA::SystemException
       )) = 0;
 
-    static void create_exception_skel (
+    static void create_home_tc_skel (
         CORBA::ServerRequest &_tao_req, 
         void *_tao_obj, 
         void *_tao_context, 
@@ -2621,28 +2311,13 @@ public:
           TAO_default_environment ()
       );
 
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
 
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
   };
 
-  class  _tao_thru_poa_collocated_Container : public virtual ::CORBA::Container,
-      public virtual _tao_thru_poa_collocated_IRObject
+  class  _tao_thru_poa_collocated_TypeCodeFactory     : public virtual ::CORBA::TypeCodeFactory
   {
   public:
-    _tao_thru_poa_collocated_Container (
+    _tao_thru_poa_collocated_TypeCodeFactory (
         TAO_Stub *stub
       );
     virtual CORBA::Boolean _is_a(
@@ -2654,90 +2329,10 @@ public:
         CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
       );
     
-        virtual CORBA::Contained_ptr lookup (
-        const char * search_name,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ContainedSeq * contents (
-        CORBA::DefinitionKind limit_type,
-        CORBA::Boolean exclude_inherited,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ContainedSeq * lookup_name (
-        const char * search_name,
-        CORBA::Long levels_to_search,
-        CORBA::DefinitionKind limit_type,
-        CORBA::Boolean exclude_inherited,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Container::DescriptionSeq * describe_contents (
-        CORBA::DefinitionKind limit_type,
-        CORBA::Boolean exclude_inherited,
-        CORBA::Long max_returned_objs,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ModuleDef_ptr create_module (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ConstantDef_ptr create_constant (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA::IDLType_ptr type,
-        const CORBA::Any & value,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::StructDef_ptr create_struct (
-        const char * id,
-        const char * name,
-        const char * version,
-        const CORBA::StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::UnionDef_ptr create_union (
+        virtual CORBA::TypeCode_ptr create_struct_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr discriminator_type,
-        const CORBA::UnionMemberSeq & members,
+        const IR::StructMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2745,11 +2340,11 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::EnumDef_ptr create_enum (
+    virtual CORBA::TypeCode_ptr create_union_tc (
         const char * id,
         const char * name,
-        const char * version,
-        const CORBA::EnumMemberSeq & members,
+        CORBA::TypeCode_ptr discriminator_type,
+        const IR::UnionMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2757,11 +2352,10 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::AliasDef_ptr create_alias (
+    virtual CORBA::TypeCode_ptr create_enum_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr original_type,
+        const IR::EnumMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2769,11 +2363,10 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::InterfaceDef_ptr create_interface (
+    virtual CORBA::TypeCode_ptr create_alias_tc (
         const char * id,
         const char * name,
-        const char * version,
-        const CORBA::InterfaceDefSeq & base_interfaces,
+        CORBA::TypeCode_ptr original_type,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2781,17 +2374,10 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::ValueDef_ptr create_value (
+    virtual CORBA::TypeCode_ptr create_exception_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::Boolean is_custom,
-        CORBA::Boolean is_abstract,
-        CORBA::ValueDef_ptr base_value,
-        CORBA::Boolean is_truncatable,
-        const CORBA::ValueDefSeq & abstract_base_values,
-        CORBA::InterfaceDef_ptr supported_interface,
-        const CORBA::InitializerSeq & initializers,
+        const IR::StructMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2799,11 +2385,9 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::ValueBoxDef_ptr create_value_box (
+    virtual CORBA::TypeCode_ptr create_interface_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr original_type_def,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -2811,457 +2395,8 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::ExceptionDef_ptr create_exception (
-        const char * id,
-        const char * name,
-        const char * version,
-        const CORBA::StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class IDLType;
-  typedef IDLType *IDLType_ptr;
-  class TAO_Export IDLType : public virtual IRObject
-  {
-  protected:
-    IDLType (void);
-
-  public:
-    IDLType (const IDLType& rhs);
-    virtual ~IDLType (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::IDLType *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_IDLType : public virtual ::CORBA::IDLType,
-      public virtual _tao_thru_poa_collocated_IRObject
-  {
-  public:
-    _tao_thru_poa_collocated_IDLType (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class Repository;
-  typedef Repository *Repository_ptr;
-  class TAO_Export Repository : public virtual Container
-  {
-  protected:
-    Repository (void);
-
-  public:
-    Repository (const Repository& rhs);
-    virtual ~Repository (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::Repository *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::Contained_ptr lookup_id (
-        const char * search_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void lookup_id_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::PrimitiveDef_ptr get_primitive (
-        CORBA::PrimitiveKind kind,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void get_primitive_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::StringDef_ptr create_string (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_string_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::WstringDef_ptr create_wstring (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_wstring_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::SequenceDef_ptr create_sequence (
+    virtual CORBA::TypeCode_ptr create_string_tc (
         CORBA::ULong bound,
-        CORBA::IDLType_ptr element_type,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_sequence_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::ArrayDef_ptr create_array (
-        CORBA::ULong length,
-        CORBA::IDLType_ptr element_type,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_array_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::FixedDef_ptr create_fixed (
-        CORBA::UShort digits,
-        CORBA::Short scale,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_fixed_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void lookup_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void lookup_name_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_module_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_constant_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_struct_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_union_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_enum_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_alias_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_interface_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_box_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_exception_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_Repository : public virtual ::CORBA::Repository,
-      public virtual _tao_thru_poa_collocated_Container
-  {
-  public:
-    _tao_thru_poa_collocated_Repository (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::Contained_ptr lookup_id (
-        const char * search_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::PrimitiveDef_ptr get_primitive (
-        CORBA::PrimitiveKind kind,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -3269,7 +2404,7 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::StringDef_ptr create_string (
+    virtual CORBA::TypeCode_ptr create_wstring_tc (
         CORBA::ULong bound,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
@@ -3278,3038 +2413,29 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::WstringDef_ptr create_wstring (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::SequenceDef_ptr create_sequence (
-        CORBA::ULong bound,
-        CORBA::IDLType_ptr element_type,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ArrayDef_ptr create_array (
-        CORBA::ULong length,
-        CORBA::IDLType_ptr element_type,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::FixedDef_ptr create_fixed (
+    virtual CORBA::TypeCode_ptr create_fixed_tc (
         CORBA::UShort digits,
-        CORBA::Short scale,
+        CORBA::UShort scale,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
-  };
-
-  class ModuleDef;
-  typedef ModuleDef *ModuleDef_ptr;
-  class TAO_Export ModuleDef : public virtual Container, 
-                               public virtual Contained
-  {
-  protected:
-    ModuleDef (void);
 
-  public:
-    ModuleDef (const ModuleDef& rhs);
-    virtual ~ModuleDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::ModuleDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    static void lookup_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void lookup_name_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_module_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_constant_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_struct_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_union_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_enum_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_alias_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_interface_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_box_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_exception_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_ModuleDef : public virtual ::CORBA::ModuleDef,
-      public virtual _tao_thru_poa_collocated_Container,
-      public virtual _tao_thru_poa_collocated_Contained
-  {
-  public:
-    _tao_thru_poa_collocated_ModuleDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );    
-  };
-
-  class ConstantDef;
-  typedef ConstantDef *ConstantDef_ptr;
-  class TAO_Export ConstantDef : public virtual Contained
-  {
-  protected:
-    ConstantDef (void);
-
-  public:
-    ConstantDef (const ConstantDef& rhs);
-    virtual ~ConstantDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::ConstantDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::IDLType_ptr type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void type_def (
-        CORBA::IDLType_ptr type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Any * value (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_value_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void value (
-        const CORBA::Any & value,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_value_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_ConstantDef : public virtual ::CORBA::ConstantDef,
-      public virtual _tao_thru_poa_collocated_Contained
-  {
-  public:
-    _tao_thru_poa_collocated_ConstantDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::IDLType_ptr type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void type_def (
-        CORBA::IDLType_ptr type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Any * value (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void value (
-        const CORBA::Any & value,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class TypedefDef;
-  typedef TypedefDef *TypedefDef_ptr;
-  class TAO_Export TypedefDef : public virtual Contained, 
-                                public virtual IDLType
-  {
-  protected:
-    TypedefDef (void);
-
-  public:
-    TypedefDef (const TypedefDef& rhs);
-    virtual ~TypedefDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::TypedefDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_TypedefDef : public virtual ::CORBA::TypedefDef,
-      public virtual _tao_thru_poa_collocated_Contained,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_TypedefDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );    
-  };
-
-  class StructDef;
-  typedef StructDef *StructDef_ptr;
-  class TAO_Export StructDef : public virtual TypedefDef, 
-                               public virtual Container
-  {
-  protected:
-    StructDef (void);
-
-  public:
-    StructDef (const StructDef& rhs);
-    virtual ~StructDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::StructDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::StructMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_members_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void members (
-        const CORBA::StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_members_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void lookup_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void lookup_name_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_module_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_constant_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_struct_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_union_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_enum_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_alias_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_interface_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_box_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_exception_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_StructDef : public virtual ::CORBA::StructDef,
-      public virtual _tao_thru_poa_collocated_TypedefDef,
-      public virtual _tao_thru_poa_collocated_Container
-  {
-  public:
-    _tao_thru_poa_collocated_StructDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::StructMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void members (
-        const CORBA::StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class UnionDef;
-  typedef UnionDef *UnionDef_ptr;
-  class TAO_Export UnionDef : public virtual TypedefDef, 
-                              public virtual Container
-  {
-  protected:
-    UnionDef (void);
-
-  public:
-    UnionDef (const UnionDef& rhs);
-    virtual ~UnionDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::UnionDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::TypeCode_ptr discriminator_type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_discriminator_type_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::IDLType_ptr discriminator_type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_discriminator_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void discriminator_type_def (
-        CORBA::IDLType_ptr discriminator_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_discriminator_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::UnionMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_members_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void members (
-        const CORBA::UnionMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_members_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void lookup_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void lookup_name_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_module_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_constant_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_struct_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_union_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_enum_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_alias_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_interface_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_box_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_exception_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_UnionDef : public virtual ::CORBA::UnionDef,
-      public virtual _tao_thru_poa_collocated_TypedefDef,
-      public virtual _tao_thru_poa_collocated_Container
-  {
-  public:
-    _tao_thru_poa_collocated_UnionDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::TypeCode_ptr discriminator_type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::IDLType_ptr discriminator_type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void discriminator_type_def (
-        CORBA::IDLType_ptr discriminator_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::UnionMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void members (
-        const CORBA::UnionMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class EnumDef;
-  typedef EnumDef *EnumDef_ptr;
-  class TAO_Export EnumDef : public virtual TypedefDef
-  {
-  protected:
-    EnumDef (void);
-
-  public:
-    EnumDef (const EnumDef& rhs);
-    virtual ~EnumDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::EnumDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::EnumMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_members_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void members (
-        const CORBA::EnumMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_members_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_EnumDef : public virtual ::CORBA::EnumDef,
-      public virtual _tao_thru_poa_collocated_TypedefDef
-  {
-  public:
-    _tao_thru_poa_collocated_EnumDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::EnumMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void members (
-        const CORBA::EnumMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class AliasDef;
-  typedef AliasDef *AliasDef_ptr;
-  class TAO_Export AliasDef : public virtual TypedefDef
-  {
-  protected:
-    AliasDef (void);
-
-  public:
-    AliasDef (const AliasDef& rhs);
-    virtual ~AliasDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::AliasDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::IDLType_ptr original_type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_original_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void original_type_def (
-        CORBA::IDLType_ptr original_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_original_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_AliasDef : public virtual ::CORBA::AliasDef,
-      public virtual _tao_thru_poa_collocated_TypedefDef
-  {
-  public:
-    _tao_thru_poa_collocated_AliasDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::IDLType_ptr original_type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void original_type_def (
-        CORBA::IDLType_ptr original_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-  };
-
-  class PrimitiveDef;
-  typedef PrimitiveDef *PrimitiveDef_ptr;
-  class TAO_Export PrimitiveDef : public virtual IDLType
-  {
-  protected:
-    PrimitiveDef (void);
-
-  public:
-    PrimitiveDef (const PrimitiveDef& rhs);
-    virtual ~PrimitiveDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::PrimitiveDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::PrimitiveKind kind (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_kind_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_PrimitiveDef : public virtual ::CORBA::PrimitiveDef,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_PrimitiveDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::PrimitiveKind kind (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class StringDef;
-  typedef StringDef *StringDef_ptr;
-  class TAO_Export StringDef : public virtual IDLType
-  {
-  protected:
-    StringDef (void);
-
-  public:
-    StringDef (const StringDef& rhs);
-    virtual ~StringDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::StringDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::ULong bound (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_bound_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void bound (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_bound_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_StringDef : public virtual ::CORBA::StringDef,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_StringDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::ULong bound (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void bound (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class WstringDef;
-  typedef WstringDef *WstringDef_ptr;
-  class TAO_Export WstringDef : public virtual IDLType
-  {
-  protected:
-    WstringDef (void);
-
-  public:
-    WstringDef (const WstringDef& rhs);
-    virtual ~WstringDef (void);
-
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::WstringDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::ULong bound (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_bound_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void bound (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_bound_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_WstringDef : public virtual ::CORBA::WstringDef,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_WstringDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::ULong bound (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void bound (
+    virtual CORBA::TypeCode_ptr create_sequence_tc (
         CORBA::ULong bound,
+        CORBA::TypeCode_ptr element_type,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
       ACE_THROW_SPEC ((
         CORBA::SystemException
       ));
-  };
-
-  class FixedDef;
-  typedef FixedDef *FixedDef_ptr;
-  class TAO_Export FixedDef : public virtual IDLType
-  {
-  protected:
-    FixedDef (void);
-
-  public:
-    FixedDef (const FixedDef& rhs);
-    virtual ~FixedDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
 
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::FixedDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::UShort digits (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_digits_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void digits (
-        CORBA::UShort digits,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_digits_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Short scale (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_scale_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void scale (
-        CORBA::Short scale,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_scale_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_FixedDef : public virtual ::CORBA::FixedDef,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_FixedDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::UShort digits (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void digits (
-        CORBA::UShort digits,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Short scale (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void scale (
-        CORBA::Short scale,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class SequenceDef;
-  typedef SequenceDef *SequenceDef_ptr;
-  class TAO_Export SequenceDef : public virtual IDLType
-  {
-  protected:
-    SequenceDef (void);
-
-  public:
-    SequenceDef (const SequenceDef& rhs);
-    virtual ~SequenceDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::SequenceDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::ULong bound (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_bound_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void bound (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_bound_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::TypeCode_ptr element_type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_element_type_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::IDLType_ptr element_type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_element_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void element_type_def (
-        CORBA::IDLType_ptr element_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_element_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_SequenceDef : public virtual ::CORBA::SequenceDef,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_SequenceDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::ULong bound (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void bound (
-        CORBA::ULong bound,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::TypeCode_ptr element_type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::IDLType_ptr element_type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void element_type_def (
-        CORBA::IDLType_ptr element_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class ArrayDef;
-  typedef ArrayDef *ArrayDef_ptr;
-  class TAO_Export ArrayDef : public virtual IDLType
-  {
-  protected:
-    ArrayDef (void);
-
-  public:
-    ArrayDef (const ArrayDef& rhs);
-    virtual ~ArrayDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::ArrayDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::ULong length (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_length_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void length (
-        CORBA::ULong length,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_length_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::TypeCode_ptr element_type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_element_type_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::IDLType_ptr element_type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_element_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void element_type_def (
-        CORBA::IDLType_ptr element_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_element_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_ArrayDef : public virtual ::CORBA::ArrayDef,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_ArrayDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::ULong length (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void length (
+    virtual CORBA::TypeCode_ptr create_array_tc (
         CORBA::ULong length,
+        CORBA::TypeCode_ptr element_type,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -6317,1546 +2443,12 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::TypeCode_ptr element_type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::IDLType_ptr element_type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void element_type_def (
-        CORBA::IDLType_ptr element_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class ExceptionDef;
-  typedef ExceptionDef *ExceptionDef_ptr;
-  class TAO_Export ExceptionDef : public virtual Contained, 
-                                  public virtual Container
-  {
-  protected:
-    ExceptionDef (void);
-
-  public:
-    ExceptionDef (const ExceptionDef& rhs);
-    virtual ~ExceptionDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::ExceptionDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::StructMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_members_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void members (
-        const CORBA::StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_members_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void lookup_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void lookup_name_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_module_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_constant_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_struct_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_union_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_enum_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_alias_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_interface_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_box_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_exception_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_ExceptionDef : public virtual ::CORBA::ExceptionDef,
-      public virtual _tao_thru_poa_collocated_Contained,
-      public virtual _tao_thru_poa_collocated_Container
-  {
-  public:
-    _tao_thru_poa_collocated_ExceptionDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::StructMemberSeq * members (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void members (
-        const CORBA::StructMemberSeq & members,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class AttributeDef;
-  typedef AttributeDef *AttributeDef_ptr;
-  class TAO_Export AttributeDef : public virtual Contained
-  {
-  protected:
-    AttributeDef (void);
-
-  public:
-    AttributeDef (const AttributeDef& rhs);
-    virtual ~AttributeDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::AttributeDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::IDLType_ptr type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void type_def (
-        CORBA::IDLType_ptr type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::AttributeMode mode (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_mode_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void mode (
-        CORBA::AttributeMode mode,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_mode_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_AttributeDef : public virtual ::CORBA::AttributeDef,
-      public virtual _tao_thru_poa_collocated_Contained
-  {
-  public:
-    _tao_thru_poa_collocated_AttributeDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::IDLType_ptr type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void type_def (
-        CORBA::IDLType_ptr type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::AttributeMode mode (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void mode (
-        CORBA::AttributeMode mode,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class OperationDef;
-  typedef OperationDef *OperationDef_ptr;
-  class TAO_Export OperationDef : public virtual Contained
-  {
-  protected:
-    OperationDef (void);
-
-  public:
-    OperationDef (const OperationDef& rhs);
-    virtual ~OperationDef (void);
-
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::OperationDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::TypeCode_ptr result (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_result_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::IDLType_ptr result_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_result_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void result_def (
-        CORBA::IDLType_ptr result_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_result_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::ParDescriptionSeq * params (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_params_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void params (
-        const CORBA::ParDescriptionSeq & params,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_params_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::OperationMode mode (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_mode_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void mode (
-        CORBA::OperationMode mode,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_mode_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::ContextIdSeq * contexts (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_contexts_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void contexts (
-        const CORBA::ContextIdSeq & contexts,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_contexts_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::ExceptionDefSeq * exceptions (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_exceptions_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void exceptions (
-        const CORBA::ExceptionDefSeq & exceptions,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_exceptions_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_OperationDef : public virtual ::CORBA::OperationDef,
-      public virtual _tao_thru_poa_collocated_Contained
-  {
-  public:
-    _tao_thru_poa_collocated_OperationDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::TypeCode_ptr result (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::IDLType_ptr result_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void result_def (
-        CORBA::IDLType_ptr result_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ParDescriptionSeq * params (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void params (
-        const CORBA::ParDescriptionSeq & params,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::OperationMode mode (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void mode (
-        CORBA::OperationMode mode,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ContextIdSeq * contexts (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void contexts (
-        const CORBA::ContextIdSeq & contexts,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ExceptionDefSeq * exceptions (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void exceptions (
-        const CORBA::ExceptionDefSeq & exceptions,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class InterfaceDef;
-  typedef InterfaceDef *InterfaceDef_ptr;
-  class TAO_Export InterfaceDef : public virtual Container, 
-                                  public virtual Contained, 
-                                  public virtual IDLType
-  {
-  protected:
-    InterfaceDef (void);
-
-  public:
-    InterfaceDef (const InterfaceDef& rhs);
-    virtual ~InterfaceDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::InterfaceDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::InterfaceDefSeq * base_interfaces (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_base_interfaces_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void base_interfaces (
-        const CORBA::InterfaceDefSeq & base_interfaces,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_base_interfaces_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Boolean is_a (
-        const char * interface_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void is_a_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::InterfaceDef::FullInterfaceDescription * describe_interface (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void describe_interface_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::AttributeDef_ptr create_attribute (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA::IDLType_ptr type,
-        CORBA::AttributeMode mode,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_attribute_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::OperationDef_ptr create_operation (
+    virtual CORBA::TypeCode_ptr create_value_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr result,
-        CORBA::OperationMode mode,
-        const CORBA::ParDescriptionSeq & params,
-        const CORBA::ExceptionDefSeq & exceptions,
-        const CORBA::ContextIdSeq & contexts,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_operation_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void lookup_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void lookup_name_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_module_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_constant_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_struct_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_union_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_enum_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_alias_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_interface_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_box_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_exception_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_InterfaceDef : public virtual ::CORBA::InterfaceDef,
-      public virtual _tao_thru_poa_collocated_Container,
-      public virtual _tao_thru_poa_collocated_Contained,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_InterfaceDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::InterfaceDefSeq * base_interfaces (
+        CORBA::ValueModifier type_modifier,
+        CORBA::TypeCode_ptr concrete_base,
+        const IR::ValueMemberSeq & members,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -7864,38 +2456,10 @@ public:
         CORBA::SystemException
       ));
 
-    virtual void base_interfaces (
-        const CORBA::InterfaceDefSeq & base_interfaces,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Boolean is_a (
-        const char * interface_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::InterfaceDef::FullInterfaceDescription * describe_interface (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::AttributeDef_ptr create_attribute (
+    virtual CORBA::TypeCode_ptr create_value_box_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr type,
-        CORBA::AttributeMode mode,
+        CORBA::TypeCode_ptr boxed_type,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -7903,286 +2467,9 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::OperationDef_ptr create_operation (
+    virtual CORBA::TypeCode_ptr create_native_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr result,
-        CORBA::OperationMode mode,
-        const CORBA::ParDescriptionSeq & params,
-        const CORBA::ExceptionDefSeq & exceptions,
-        const CORBA::ContextIdSeq & contexts,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class ValueMemberDef;
-  typedef ValueMemberDef *ValueMemberDef_ptr;
-  class TAO_Export ValueMemberDef : public virtual Contained
-  {
-  protected:
-    ValueMemberDef (void);
-
-  public:
-    ValueMemberDef (const ValueMemberDef& rhs);
-    virtual ~ValueMemberDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::ValueMemberDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::IDLType_ptr type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void type_def (
-        CORBA::IDLType_ptr type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Visibility access (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_access_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void access (
-        CORBA::Visibility access,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_access_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_ValueMemberDef : public virtual ::CORBA::ValueMemberDef,
-      public virtual _tao_thru_poa_collocated_Contained
-  {
-  public:
-    _tao_thru_poa_collocated_ValueMemberDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::TypeCode_ptr type (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::IDLType_ptr type_def (
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -8190,788 +2477,8 @@ public:
         CORBA::SystemException
       ));
 
-    virtual void type_def (
-        CORBA::IDLType_ptr type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Visibility access (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void access (
-        CORBA::Visibility access,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class ValueDef;
-  typedef ValueDef *ValueDef_ptr;
-  class TAO_Export ValueDef : public virtual Container, 
-                              public virtual Contained, 
-                              public virtual IDLType
-  {
-  protected:
-    ValueDef (void);
-
-  public:
-    ValueDef (const ValueDef& rhs);
-    virtual ~ValueDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::ValueDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::InterfaceDef_ptr supported_interface (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_supported_interface_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void supported_interface (
-        CORBA::InterfaceDef_ptr supported_interface,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_supported_interface_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::InitializerSeq * initializers (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_initializers_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void initializers (
-        const CORBA::InitializerSeq & initializers,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_initializers_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::ValueDef_ptr base_value (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_base_value_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void base_value (
-        CORBA::ValueDef_ptr base_value,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_base_value_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::ValueDefSeq * abstract_base_values (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_abstract_base_values_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void abstract_base_values (
-        const CORBA::ValueDefSeq & abstract_base_values,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_abstract_base_values_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Boolean is_abstract (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_is_abstract_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void is_abstract (
-        CORBA::Boolean is_abstract,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_is_abstract_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Boolean is_custom (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_is_custom_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void is_custom (
-        CORBA::Boolean is_custom,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_is_custom_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Boolean is_truncatable (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_is_truncatable_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void is_truncatable (
-        CORBA::Boolean is_truncatable,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_is_truncatable_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::Boolean is_a (
-        const char * value_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void is_a_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::ValueDef::FullValueDescription * describe_value (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void describe_value_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::ValueMemberDef_ptr create_value_member (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA::IDLType_ptr type,
-        CORBA::Visibility access,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_value_member_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::AttributeDef_ptr create_attribute (
-        const char * id,
-        const char * name,
-        const char * version,
-        CORBA::IDLType_ptr type,
-        CORBA::AttributeMode mode,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_attribute_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual CORBA::OperationDef_ptr create_operation (
+    virtual CORBA::TypeCode_ptr create_recursive_tc (
         const char * id,
-        const char * name,
-        const char * version,
-        CORBA::IDLType_ptr result,
-        CORBA::OperationMode mode,
-        const CORBA::ParDescriptionSeq & params,
-        const CORBA::ExceptionDefSeq & exceptions,
-        const CORBA::ContextIdSeq & contexts,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void create_operation_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void lookup_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void lookup_name_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_contents_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_module_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_constant_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_struct_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_union_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_enum_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_alias_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_interface_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_value_box_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void create_exception_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_id_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _set_version_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env = 
-          TAO_default_environment ()
-      );
-
-    static void _get_defined_in_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_absolute_name_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_containing_repository_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void describe_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void move_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_ValueDef : public virtual ::CORBA::ValueDef,
-      public virtual _tao_thru_poa_collocated_Container,
-      public virtual _tao_thru_poa_collocated_Contained,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_ValueDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::InterfaceDef_ptr supported_interface (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void supported_interface (
-        CORBA::InterfaceDef_ptr supported_interface,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::InitializerSeq * initializers (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void initializers (
-        const CORBA::InitializerSeq & initializers,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ValueDef_ptr base_value (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void base_value (
-        CORBA::ValueDef_ptr base_value,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ValueDefSeq * abstract_base_values (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void abstract_base_values (
-        const CORBA::ValueDefSeq & abstract_base_values,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Boolean is_abstract (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void is_abstract (
-        CORBA::Boolean is_abstract,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Boolean is_custom (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void is_custom (
-        CORBA::Boolean is_custom,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Boolean is_truncatable (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual void is_truncatable (
-        CORBA::Boolean is_truncatable,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::Boolean is_a (
-        const char * value_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-
-    virtual CORBA::ValueDef::FullValueDescription * describe_value (
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -8979,12 +2486,9 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::ValueMemberDef_ptr create_value_member (
+    virtual CORBA::TypeCode_ptr create_abstract_interface_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr type,
-        CORBA::Visibility access,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -8992,12 +2496,9 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::AttributeDef_ptr create_attribute (
+    virtual CORBA::TypeCode_ptr create_component_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr type,
-        CORBA::AttributeMode mode,
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -9005,149 +2506,9 @@ public:
         CORBA::SystemException
       ));
 
-    virtual CORBA::OperationDef_ptr create_operation (
+    virtual CORBA::TypeCode_ptr create_home_tc (
         const char * id,
         const char * name,
-        const char * version,
-        CORBA::IDLType_ptr result,
-        CORBA::OperationMode mode,
-        const CORBA::ParDescriptionSeq & params,
-        const CORBA::ExceptionDefSeq & exceptions,
-        const CORBA::ContextIdSeq & contexts,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
-  };
-
-  class ValueBoxDef;
-  typedef ValueBoxDef *ValueBoxDef_ptr;
-  class TAO_Export ValueBoxDef : public virtual IDLType
-  {
-  protected:
-    ValueBoxDef (void);
-
-  public:
-    ValueBoxDef (const ValueBoxDef& rhs);
-    virtual ~ValueBoxDef (void);
-
-    virtual CORBA::Boolean _is_a (
-        const char* logical_type_id,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void* _downcast (
-        const char* logical_type_id
-      );
-
-    static void _is_a_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _non_existent_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void _dispatch (
-        CORBA::ServerRequest &_tao_req,
-        void *_tao_context,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    ::CORBA::ValueBoxDef *_this (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual const char* _interface_repository_id (void) const;
-
-    virtual CORBA::IDLType_ptr original_type_def (
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _get_original_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    virtual void original_type_def (
-        CORBA::IDLType_ptr original_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      )) = 0;
-
-    static void _set_original_type_def_skel (
-        CORBA::ServerRequest &_tao_req, 
-        void *_tao_obj, 
-        void *_tao_context, 
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      );
-
-    static void _get_type_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void _get_def_kind_skel (
-        CORBA::ServerRequest &req,
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-
-    static void destroy_skel (
-        CORBA::ServerRequest &req, 
-        void *obj,
-        void *context,
-        CORBA::Environment &env =
-          TAO_default_environment ()
-      );
-  };
-
-  class  _tao_thru_poa_collocated_ValueBoxDef : public virtual ::CORBA::ValueBoxDef,
-      public virtual _tao_thru_poa_collocated_IDLType
-  {
-  public:
-    _tao_thru_poa_collocated_ValueBoxDef (
-        TAO_Stub *stub
-      );
-    virtual CORBA::Boolean _is_a(
-        const CORBA::Char *logical_type_id,
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-    virtual CORBA::Boolean _non_existent(
-        CORBA_Environment &ACE_TRY_ENV = TAO_default_environment ()
-      );
-    
-        virtual CORBA::IDLType_ptr original_type_def (
         CORBA::Environment &ACE_TRY_ENV = 
           TAO_default_environment ()
       )
@@ -9155,14 +2516,6 @@ public:
         CORBA::SystemException
       ));
 
-    virtual void original_type_def (
-        CORBA::IDLType_ptr original_type_def,
-        CORBA::Environment &ACE_TRY_ENV = 
-          TAO_default_environment ()
-      )
-      ACE_THROW_SPEC ((
-        CORBA::SystemException
-      ));
   };
 
 #endif /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
diff --git a/TAO/tao/TAO.dsp b/TAO/tao/TAO.dsp
index f90bafc3670..90f1010a0c0 100644
--- a/TAO/tao/TAO.dsp
+++ b/TAO/tao/TAO.dsp
@@ -3814,10 +3814,6 @@ SOURCE=.\InterfaceC.i
 # End Source File

 # Begin Source File

 

-SOURCE=.\InterfaceS.i

-# End Source File

-# Begin Source File

-

 SOURCE=.\Invocation.i

 # End Source File

 # Begin Source File

diff --git a/TAO/tao/corbafwd.h b/TAO/tao/corbafwd.h
index 837c6dde138..8c6a4a4bbce 100644
--- a/TAO/tao/corbafwd.h
+++ b/TAO/tao/corbafwd.h
@@ -169,7 +169,7 @@ typedef class CORBA_Exception *CORBA_Exception_ptr;
 TAO_SYSTEM_EXCEPTION_LIST
 #undef TAO_SYSTEM_EXCEPTION
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if !defined (TAO_HAS_MINIMUM_CORBA)
 
 class CORBA_WrongTransaction;
 typedef CORBA_WrongTransaction *CORBA_WrongTransaction_ptr;
@@ -351,273 +351,60 @@ class CORBA_ORB_ObjectIdList_out;
 typedef CORBA_ORB_ObjectIdList *CORBA_ORB_ObjectIdList_ptr;
 
 // Forward declarations for INTERFACE REPO..Bala
-#ifdef TAO_HAS_INTERFACE_REPOSITORY
+#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
+
+// To avoid cyclic dependencies, this is defined here and 
+// typedef'd to DefinitionKind inside the IR namespace.
+enum TAO_Export IR_DefinitionKind
+  {
+        dk_none,
+        dk_all,
+        dk_Attribute,
+        dk_Constant,
+        dk_Exception,
+        dk_Interface,
+        dk_Module,
+        dk_Operation,
+        dk_Typedef,
+        dk_Alias,
+        dk_Struct,
+        dk_Union,
+        dk_Enum,
+        dk_Primitive,
+        dk_String,
+        dk_Sequence,
+        dk_Array,
+        dk_Repository,
+        dk_Wstring,
+        dk_Fixed,
+        dk_Value,
+        dk_ValueBox,
+        dk_ValueMember,
+        dk_Native,
+        dk_Component,
+        dk_Home,
+        dk_Factory,
+        dk_Finder,
+        dk_PrimaryKey,
+        dk_Emits,
+        dk_Publishes,
+        dk_Consumes,
+        dk_Provides,
+        dk_Uses,
+        IR_DefinitionKind_TAO_ENUM_32BIT_ENFORCER = 0x7FFFFFFF
+  };
 
 class CORBA_IRObject;
 class CORBA_IRObject_var;
 class CORBA_IRObject_out;
 typedef CORBA_IRObject *CORBA_IRObject_ptr;
 
-class CORBA_Contained;
-class CORBA_Contained_out;
-class CORBA_Contained_var;
-typedef CORBA_Contained *CORBA_Contained_ptr;
-
-class CORBA_Repository;
-class CORBA_Repository_var;
-class CORBA_Repository_out;
-typedef CORBA_Repository *CORBA_Repository_ptr;
-
-class CORBA_Container;
-class CORBA_Container_var;
-class CORBA_Container_out;
-typedef CORBA_Container *CORBA_Container_ptr;
-
-class CORBA_ModuleDef;
-class CORBA_ModuleDef_out;
-class CORBA_ModuleDef_var;
-typedef CORBA_ModuleDef *CORBA_ModuleDef_ptr;
-
-class CORBA_ConstantDef;
-class CORBA_ConstantDef_out;
-class CORBA_ConstantDef_var;
-typedef CORBA_ConstantDef *CORBA_ConstantDef_ptr;
-
-class CORBA_IDLType;
-class CORBA_IDLType_out;
-class CORBA_IDLType_var;
-typedef CORBA_IDLType *CORBA_IDLType_ptr;
-
-class CORBA_StructDef;
-class CORBA_StructDef_var;
-class CORBA_StructDef_out;
-typedef  CORBA_StructDef *CORBA_StructDef_ptr;
-
-class CORBA_UnionDef;
-class CORBA_UnionDef_var;
-class CORBA_UnionDef_out;
-typedef CORBA_UnionDef *CORBA_UnionDef_ptr;
-
-class CORBA_EnumDef;
-class CORBA_EnumDef_var;
-class CORBA_EnumDef_out;
-typedef CORBA_EnumDef *CORBA_EnumDef_ptr;
-
-class CORBA_AliasDef;
-class CORBA_AliasDef_var;
-class CORBA_AliasDef_out;
-typedef CORBA_AliasDef *CORBA_AliasDef_ptr;
-
-class CORBA_ExceptionDef;
-class CORBA_ExceptionDef_out;
-class CORBA_ExceptionDef_var;
-typedef CORBA_ExceptionDef *CORBA_ExceptionDef_ptr;
-
-class CORBA_NativeDef;
-class CORBA_NativeDef_out;
-class CORBA_NativeDef_var;
-typedef CORBA_NativeDef *CORBA_NativeDef_ptr;
-
-class CORBA_InterfaceDefSeq;
-class CORBA_InterfaceDefSeq_out;
-class CORBA_InterfaceDefSeq_var;
-typedef CORBA_InterfaceDefSeq *CORBA_InterfaceDefSeq_ptr;
-
-class CORBA_ValueDef;
-class CORBA_ValueDef_out;
-class CORBA_ValueDef_var;
-typedef CORBA_ValueDef *CORBA_ValueDef_ptr;
-
-class CORBA_ValueDefSeq;
-class CORBA_ValueDefSeq_out;
-class CORBA_ValueDefSeq_var;
-typedef CORBA_ValueDefSeq *CORBA_ValueDefSeq_ptr;
-
-class CORBA_ValueBoxDef;
-class CORBA_ValueBoxDef_out;
-class CORBA_ValueBoxDef_var;
-typedef CORBA_ValueBoxDef *CORBA_ValueBoxDef_ptr;
-
-class CORBA_ContainedSeq;
-class CORBA_ContainedSeq_out;
-class CORBA_ContainedSeq_var;
-typedef CORBA_ContainedSeq *CORBA_ContainedSeq_ptr;
-
-struct CORBA_StructMember;
-class CORBA_StructMember_out;
-class CORBA_StructMember_var;
-typedef CORBA_StructMember *CORBA_StructMember_ptr;
-
-class CORBA_StructMemberSeq;
-class CORBA_StructMemberSeq_out;
-class CORBA_StructMemberSeq_var;
-typedef CORBA_StructMemberSeq *CORBA_StructMemberSeq_ptr;
-
-struct CORBA_Initializer;
-class CORBA_Initializer_out;
-class CORBA_Initializer_var;
-typedef CORBA_Initializer *CORBA_Initializer_ptr;
-
-class CORBA_InitializerSeq;
-class CORBA_InitializerSeq_out;
-class CORBA_InitializerSeq_var;
-typedef CORBA_InitializerSeq *CORBA_InitializerSeq_ptr;
-
-struct CORBA_UnionMember;
-class CORBA_UnionMember_out;
-class CORBA_UnionMember_var;
-typedef CORBA_UnionMember *CORBA_UnionMember_ptr;
-
-class CORBA_UnionMemberSeq;
-class CORBA_UnionMemberSeq_out;
-class CORBA_UnionMemberSeq_var;
-typedef CORBA_UnionMemberSeq *CORBA_UnionMemberSeq_ptr;
-
-class CORBA_PrimitiveDef;
-class CORBA_PrimitiveDef_out;
-class CORBA_PrimitiveDef_var;
-typedef CORBA_PrimitiveDef *CORBA_PrimitiveDef_ptr;
-
-class CORBA_StringDef;
-class CORBA_StringDef_out;
-class CORBA_StringDef_var;
-typedef CORBA_StringDef *CORBA_StringDef_ptr;
-
-class CORBA_SequenceDef;
-class CORBA_SequenceDef_out;
-class CORBA_SequenceDef_var;
-typedef CORBA_SequenceDef *CORBA_SequenceDef_ptr;
-
-class CORBA_ArrayDef;
-class CORBA_ArrayDef_out;
-class CORBA_ArrayDef_var;
-typedef CORBA_ArrayDef *CORBA_ArrayDef_ptr;
-
-class CORBA_WstringDef;
-class CORBA_WstringDef_out;
-class CORBA_WstringDef_var;
-typedef CORBA_WstringDef *CORBA_WstringDef_ptr;
-
-class CORBA_FixedDef;
-class CORBA_FixedDef_out;
-class CORBA_FixedDef_var;
-typedef CORBA_FixedDef *CORBA_FixedDef_ptr;
-
-struct CORBA_ModuleDescription;
-class CORBA_ModuleDescription_out;
-class CORBA_ModuleDescription_var;
-typedef CORBA_ModuleDescription *CORBA_ModuleDescription_ptr;
-
-struct CORBA_ConstantDescription;
-class CORBA_ConstantDescription_out;
-class CORBA_ConstantDescription_var;
-typedef CORBA_ConstantDescription *CORBA_ConstantDescription_ptr;
-
-class CORBA_TypedefDef;
-class CORBA_TypedefDef_out;
-class CORBA_TypedefDef_var;
-typedef CORBA_TypedefDef *CORBA_TypedefDef_ptr;
-
-struct CORBA_TypeDescription;
-class CORBA_TypeDescription_out;
-class CORBA_TypeDescription_var;
-typedef CORBA_TypeDescription *CORBA_TypeDescription_ptr;
-
-struct CORBA_ExceptionDescription;
-class CORBA_ExceptionDescription_out;
-class CORBA_ExceptionDescription_var;
-typedef CORBA_ExceptionDescription *CORBA_ExceptionDescription_ptr;
-
-class CORBA_AttributeDef;
-class CORBA_AttributeDef_out;
-class CORBA_AttributeDef_var;
-typedef CORBA_AttributeDef *CORBA_AttributeDef_ptr;
-
-struct CORBA_AttributeDescription;
-class CORBA_AttributeDescription_out;
-class CORBA_AttributeDescription_var;
-typedef CORBA_AttributeDescription *CORBA_AttributeDescription_ptr;
-
-struct CORBA_ParameterDescription;
-class CORBA_ParameterDescription_out;
-class CORBA_ParameterDescription_var;
-typedef CORBA_ParameterDescription *CORBA_ParameterDescription_ptr;
-
-class CORBA_ParDescriptionSeq;
-class CORBA_ParDescriptionSeq_out;
-class CORBA_ParDescriptionSeq_var;
-typedef CORBA_ParDescriptionSeq *CORBA_ParDescriptionSeq_ptr;
-
-class CORBA_ContextIdSeq;
-class CORBA_ContextIdSeq_out;
-class CORBA_ContextIdSeq_var;
-typedef CORBA_ContextIdSeq *CORBA_ContextIdSeq_ptr;
-
-class CORBA_ExceptionDefSeq;
-class CORBA_ExceptionDefSeq_out;
-class CORBA_ExceptionDefSeq_var;
-typedef CORBA_ExceptionDefSeq *CORBA_ExceptionDefSeq_ptr;
-
-class CORBA_ExcDescriptionSeq;
-class CORBA_ExcDescriptionSeq_out;
-class CORBA_ExcDescriptionSeq_var;
-typedef CORBA_ExcDescriptionSeq *CORBA_ExcDescriptionSeq_ptr;
-
-class CORBA_OperationDef;
-class CORBA_OperationDef_out;
-class CORBA_OperationDef_var;
-typedef CORBA_OperationDef *CORBA_OperationDef_ptr;
-
-struct CORBA_OperationDescription;
-class CORBA_OperationDescription_out;
-class CORBA_OperationDescription_var;
-typedef CORBA_OperationDescription *CORBA_OperationDescription_ptr;
-
-class CORBA_RepositoryIdSeq;
-class CORBA_RepositoryIdSeq_out;
-class CORBA_RepositoryIdSeq_var;
-typedef CORBA_RepositoryIdSeq *CORBA_RepositoryIdSeq_ptr;
-
-class CORBA_OpDescriptionSeq;
-class CORBA_OpDescriptionSeq_out;
-class CORBA_OpDescriptionSeq_var;
-typedef CORBA_OpDescriptionSeq *CORBA_OpDescriptionSeq_ptr;
-
-class CORBA_AttrDescriptionSeq;
-class CORBA_AttrDescriptionSeq_out;
-class CORBA_AttrDescriptionSeq_var;
-typedef CORBA_AttrDescriptionSeq *CORBA_AttrDescriptionSeq_ptr;
-
-struct CORBA_InterfaceDescription;
-class CORBA_InterfaceDescription_out;
-class CORBA_InterfaceDescription_var;
-typedef CORBA_InterfaceDescription *CORBA_InterfaceDescription_ptr;
-
-struct CORBA_ValueMember;
-class CORBA_ValueMember_out;
-class CORBA_ValueMember_var;
-typedef CORBA_ValueMember *CORBA_ValueMember_ptr;
-
-class CORBA_ValueMemberSeq;
-class CORBA_ValueMemberSeq_out;
-class CORBA_ValueMemberSeq_var;
-typedef CORBA_ValueMemberSeq *CORBA_ValueMemberSeq_ptr;
-
-class CORBA_ValueMemberDef;
-class CORBA_ValueMemberDef_out;
-class CORBA_ValueMemberDef_var;
-typedef CORBA_ValueMemberDef *CORBA_ValueMemberDef_ptr;
-
-struct CORBA_ValueDescription;
-class CORBA_ValueDescription_out;
-class CORBA_ValueDescription_var;
-typedef CORBA_ValueDescription *CORBA_ValueDescription_ptr;
-
-class CORBA_EnumMemberSeq;
-class CORBA_EnumMemberSeq_out;
-class CORBA_EnumMemberSeq_var;
-typedef CORBA_EnumMemberSeq *CORBA_EnumMemberSeq_ptr;
-#endif /* TAO_HAS_INTERFACE_REPOSITORY*/
+class CORBA_TypeCodeFactory;
+class CORBA_TypeCodeFactory_var;
+class CORBA_TypeCodeFactory_out;
+typedef CORBA_TypeCodeFactory *CORBA_TypeCodeFactory_ptr;
+
+#endif /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
 
 class CORBA_Bounds;
 typedef CORBA_Bounds *CORBA_Bounds_ptr;
@@ -737,7 +524,7 @@ TAO_NAMESPACE CORBA
   typedef CORBA_SystemException SystemException;
   typedef CORBA_UserException  UserException;
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if !defined (TAO_HAS_MINIMUM_CORBA)
 
   typedef CORBA_DynAny DynAny;
   typedef DynAny *DynAny_ptr;
@@ -834,272 +621,18 @@ TAO_NAMESPACE CORBA
   typedef CORBA_Current_var Current_var;
   typedef CORBA_Current_out Current_out;
 
-#ifdef TAO_HAS_INTERFACE_REPOSITORY
+#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
   // Interface Repository Bala===========
   typedef CORBA_IRObject IRObject;
   typedef CORBA_IRObject *IRObject_ptr;
   typedef CORBA_IRObject_out IRObject_out;
   typedef CORBA_IRObject_var IRObject_var;
 
-  typedef CORBA_Contained Contained;
-  typedef CORBA_Contained *Contained_ptr;
-  typedef CORBA_Contained_out Contained_out;
-  typedef CORBA_Contained_var Contained_var;
-
-  typedef CORBA_Repository Repository;
-  typedef CORBA_Repository *Repository_ptr;
-  typedef CORBA_Repository_out Repository_out;
-  typedef CORBA_Repository_var Repository_var;
-
-  typedef CORBA_Container Container;
-  typedef CORBA_Container *Container_ptr;
-  typedef CORBA_Container_out Container_out;
-  typedef CORBA_Container_var Container_var;
-
-  typedef CORBA_ModuleDef ModuleDef;
-  typedef CORBA_ModuleDef *ModuleDef_ptr;
-  typedef CORBA_ModuleDef_out ModuleDef_out;
-  typedef CORBA_ModuleDef_var  ModuleDef_var;
-
-  typedef CORBA_ConstantDef ConstantDef;
-  typedef CORBA_ConstantDef *ConstantDef_ptr;
-  typedef CORBA_ConstantDef_out ConstantDef_out;
-  typedef CORBA_ConstantDef_var ConstantDef_var;
-
-  typedef CORBA_IDLType IDLType;
-  typedef CORBA_IDLType *IDLType_ptr;
-  typedef CORBA_IDLType_out IDLType_out;
-  typedef CORBA_IDLType_var IDLType_var;
-
-  typedef CORBA_StructDef StructDef;
-  typedef CORBA_StructDef *StructDef_ptr;
-  typedef CORBA_StructDef_out StructDef_out;
-  typedef CORBA_StructDef_var StructDef_var;
-
-  typedef CORBA_UnionDef  UnionDef;
-  typedef CORBA_UnionDef *UnionDef_ptr;
-  typedef CORBA_UnionDef_out UnionDef_out;
-  typedef CORBA_UnionDef_var UnionDef_var;
-
-  typedef CORBA_EnumDef  EnumDef;
-  typedef CORBA_EnumDef *EnumDef_ptr;
-  typedef CORBA_EnumDef_out EnumDef_out;
-  typedef CORBA_EnumDef_var EnumDef_var;
-
-  typedef CORBA_AliasDef AliasDef;
-  typedef CORBA_AliasDef *AliasDef_ptr;
-  typedef CORBA_AliasDef_out AliasDef_out;
-  typedef CORBA_AliasDef_var AliasDef_var;
-
-  typedef CORBA_ExceptionDef ExceptionDef;
-  typedef CORBA_ExceptionDef *ExceptionDef_ptr;
-  typedef CORBA_ExceptionDef_out ExceptionDef_out;
-  typedef CORBA_ExceptionDef_var ExceptionDef_var;
-
-  typedef CORBA_NativeDef NativeDef;
-  typedef CORBA_NativeDef *NativeDef_ptr;
-  typedef CORBA_NativeDef_out NativeDef_out;
-  typedef CORBA_NativeDef_var NativeDef_var;
-
-  typedef CORBA_InterfaceDefSeq InterfaceDefSeq;
-  typedef CORBA_InterfaceDefSeq *InterfaceDefSeq_ptr;
-  typedef CORBA_InterfaceDefSeq_out InterfaceDefSeq_out;
-  typedef CORBA_InterfaceDefSeq_var InterfaceDefSeq_var;
-
-  typedef CORBA_ValueDef ValueDef;
-  typedef CORBA_ValueDef *ValueDef_ptr;
-  typedef CORBA_ValueDef_out ValueDef_out;
-  typedef CORBA_ValueDef_var ValueDef_var;
-
-  typedef CORBA_ValueDefSeq ValueDefSeq;
-  typedef CORBA_ValueDefSeq *ValueDefSeq_ptr;
-  typedef CORBA_ValueDefSeq_out ValueDefSeq_out;
-  typedef CORBA_ValueDefSeq_var ValueDefSeq_var;
-
-  typedef CORBA_ValueBoxDef ValueBoxDef;
-  typedef CORBA_ValueBoxDef *ValueBoxDef_ptr;
-  typedef CORBA_ValueBoxDef_out ValueBoxDef_out;
-  typedef CORBA_ValueBoxDef_var ValueBoxDef_var;
-
-  typedef CORBA_ContainedSeq ContainedSeq;
-  typedef CORBA_ContainedSeq *ContainedSeq_ptr;
-  typedef CORBA_ContainedSeq_out ContainedSeq_out;
-  typedef CORBA_ContainedSeq_var ContainedSeq_var;
-
-  typedef CORBA_StructMember StructMember;
-  typedef CORBA_StructMember *StructMember_ptr;
-  typedef CORBA_StructMember_out StructMember_out;
-  typedef CORBA_StructMember_var StructMember_var;
-
-  typedef CORBA_StructMemberSeq StructMemberSeq;
-  typedef CORBA_StructMemberSeq *StructMemberSeq_ptr;
-  typedef CORBA_StructMemberSeq_out StructMemberSeq_out;
-  typedef CORBA_StructMemberSeq_var StructMemberSeq_var;
-
-  typedef CORBA_Initializer Initializer;
-  typedef CORBA_Initializer *Initializer_ptr;
-  typedef CORBA_Initializer_out Initializer_out;
-  typedef CORBA_Initializer_var Initializer_var;
-
-  typedef CORBA_InitializerSeq InitializerSeq;
-  typedef CORBA_InitializerSeq *InitializerSeq_ptr;
-  typedef CORBA_InitializerSeq_out InitializerSeq_out;
-  typedef CORBA_InitializerSeq_var InitializerSeq_var;
-
-  typedef CORBA_UnionMember UnionMember;
-  typedef CORBA_UnionMember *UnionMember_ptr;
-  typedef CORBA_UnionMember_out UnionMember_out;
-  typedef CORBA_UnionMember_var UnionMember_var;
-
-  typedef CORBA_UnionMemberSeq UnionMemberSeq;
-  typedef CORBA_UnionMemberSeq *UnionMemberSeq_ptr;
-  typedef CORBA_UnionMemberSeq_out UnionMemberSeq_out;
-  typedef CORBA_UnionMemberSeq_var UnionMemberSeq_var;
-
-  typedef CORBA_PrimitiveDef PrimitiveDef;
-  typedef CORBA_PrimitiveDef *PrimitiveDef_ptr;
-  typedef CORBA_PrimitiveDef_out PrimitiveDef_out;
-  typedef CORBA_PrimitiveDef_var PrimitiveDef_var;
-
-  typedef CORBA_StringDef StringDef;
-  typedef CORBA_StringDef *StringDef_ptr;
-  typedef CORBA_StringDef_out StringDef_out;
-  typedef CORBA_StringDef_var StringDef_var;
-
-  typedef CORBA_SequenceDef SequenceDef;
-  typedef CORBA_SequenceDef *SequenceDef_ptr;
-  typedef CORBA_SequenceDef_out SequenceDef_out;
-  typedef CORBA_SequenceDef_var SequenceDef_var;
-
-  typedef CORBA_ArrayDef ArrayDef;
-  typedef CORBA_ArrayDef *ArrayDef_ptr;
-  typedef CORBA_ArrayDef_out ArrayDef_out;
-  typedef CORBA_ArrayDef_var ArrayDef_var;
-
-  typedef CORBA_WstringDef WstringDef;
-  typedef CORBA_WstringDef *WstringDef_ptr;
-  typedef CORBA_WstringDef_out WstringDef_out;
-  typedef CORBA_WstringDef_var WstringDef_var;
-
-  typedef CORBA_FixedDef FixedDef;
-  typedef CORBA_FixedDef *FixedDef_ptr;
-  typedef CORBA_FixedDef_out FixedDef_out;
-  typedef CORBA_FixedDef_var FixedDef_var;
-
-  typedef CORBA_ModuleDescription ModuleDescription;
-  typedef CORBA_ModuleDescription *ModuleDescription_ptr;
-  typedef CORBA_ModuleDescription_out ModuleDescription_out;
-  typedef CORBA_ModuleDescription_var ModuleDescription_var;
-
-  typedef CORBA_ConstantDescription ConstantDescription;
-  typedef CORBA_ConstantDescription *ConstantDescription_ptr;
-  typedef CORBA_ConstantDescription_out ConstantDescription_out;
-  typedef CORBA_ConstantDescription_var ConstantDescription_var;
-
-  typedef CORBA_TypedefDef TypedefDef;
-  typedef CORBA_TypedefDef *TypedefDef_ptr;
-  typedef CORBA_TypedefDef_out TypedefDef_out;
-  typedef CORBA_TypedefDef_var TypedefDef_var;
-
-  typedef CORBA_TypeDescription TypeDescription;
-  typedef CORBA_TypeDescription *TypeDescription_ptr;
-  typedef CORBA_TypeDescription_out TypeDescription_out;
-  typedef CORBA_TypeDescription_var TypeDescription_var;
-
-  typedef CORBA_ExceptionDescription ExceptionDescription;
-  typedef CORBA_ExceptionDescription *ExceptionDescription_ptr;
-  typedef CORBA_ExceptionDescription_out ExceptionDescription_out;
-  typedef CORBA_ExceptionDescription_var ExceptionDescription_var;
-
-  typedef CORBA_AttributeDef AttributeDef;
-  typedef CORBA_AttributeDef *AttributeDef_ptr;
-  typedef CORBA_AttributeDef_out AttributeDef_out;
-  typedef CORBA_AttributeDef_var AttributeDef_var;
-
-  typedef CORBA_AttributeDescription AttributeDescription;
-  typedef CORBA_AttributeDescription *AttributeDescription_ptr;
-  typedef CORBA_AttributeDescription_out AttributeDescription_out;
-  typedef CORBA_AttributeDescription_var AttributeDescription_var;
-
-  typedef CORBA_ParameterDescription ParameterDescription;
-  typedef CORBA_ParameterDescription *ParameterDescription_ptr;
-  typedef CORBA_ParameterDescription_out ParameterDescription_out;
-  typedef CORBA_ParameterDescription_var ParameterDescription_var;
-
-  typedef CORBA_ParDescriptionSeq ParDescriptionSeq;
-  typedef CORBA_ParDescriptionSeq *ParDescriptionSeq_ptr;
-  typedef CORBA_ParDescriptionSeq_out ParDescriptionSeq_out;
-  typedef CORBA_ParDescriptionSeq_var ParDescriptionSeq_var;
-
-  typedef CORBA_ContextIdSeq ContextIdSeq;
-  typedef CORBA_ContextIdSeq *ContextIdSeq_ptr;
-  typedef CORBA_ContextIdSeq_out ContextIdSeq_out;
-  typedef CORBA_ContextIdSeq_var ContextIdSeq_var;
-
-  typedef CORBA_ExceptionDefSeq ExceptionDefSeq;
-  typedef CORBA_ExceptionDefSeq *ExceptionDefSeq_ptr;
-  typedef CORBA_ExceptionDefSeq_out ExceptionDefSeq_out;
-  typedef CORBA_ExceptionDefSeq_var ExceptionDefSeq_var;
-
-  typedef CORBA_ExcDescriptionSeq ExcDescriptionSeq;
-  typedef CORBA_ExcDescriptionSeq *ExcDescriptionSeq_ptr;
-  typedef CORBA_ExcDescriptionSeq_out ExcDescriptionSeq_out;
-  typedef CORBA_ExcDescriptionSeq_var ExcDescriptionSeq_var;
-
-  typedef CORBA_OperationDef OperationDef;
-  typedef CORBA_OperationDef *OperationDef_ptr;
-  typedef CORBA_OperationDef_out OperationDef_out;
-  typedef CORBA_OperationDef_var OperationDef_var;
-
-  typedef CORBA_OperationDescription OperationDescription;
-  typedef CORBA_OperationDescription *OperationDescription_ptr;
-  typedef CORBA_OperationDescription_out OperationDescription_out;
-  typedef CORBA_OperationDescription_var OperationDescription_var;
-
-  typedef CORBA_RepositoryIdSeq RepositoryIdSeq;
-  typedef CORBA_RepositoryIdSeq *RepositoryIdSeq_ptr;
-  typedef CORBA_RepositoryIdSeq_out RepositoryIdSeq_out;
-  typedef CORBA_RepositoryIdSeq_var RepositoryIdSeq_var;
-
-  typedef CORBA_OpDescriptionSeq OpDescriptionSeq;
-  typedef CORBA_OpDescriptionSeq *OpDescriptionSeq_ptr;
-  typedef CORBA_OpDescriptionSeq_out OpDescriptionSeq_out;
-  typedef CORBA_OpDescriptionSeq_var OpDescriptionSeq_var;
-
-  typedef CORBA_AttrDescriptionSeq AttrDescriptionSeq;
-  typedef CORBA_AttrDescriptionSeq *AttrDescriptionSeq_ptr;
-  typedef CORBA_AttrDescriptionSeq_out AttrDescriptionSeq_out;
-  typedef CORBA_AttrDescriptionSeq_var AttrDescriptionSeq_var;
-
-  typedef CORBA_InterfaceDescription InterfaceDescription;
-  typedef CORBA_InterfaceDescription *InterfaceDescription_ptr;
-  typedef CORBA_InterfaceDescription_out InterfaceDescription_out;
-  typedef CORBA_InterfaceDescription_var InterfaceDescription_var;
-
-  typedef CORBA_ValueMember ValueMember;
-  typedef CORBA_ValueMember *ValueMember_ptr;
-  typedef CORBA_ValueMember_out ValueMember_out;
-  typedef CORBA_ValueMember_var ValueMember_var;
-
-  typedef CORBA_ValueMemberSeq ValueMemberSeq;
-  typedef CORBA_ValueMemberSeq *ValueMemberSeq_ptr;
-  typedef CORBA_ValueMemberSeq_out ValueMemberSeq_out;
-  typedef CORBA_ValueMemberSeq_var ValueMemberSeq_var;
-
-  typedef CORBA_ValueMemberDef ValueMemberDef;
-  typedef CORBA_ValueMemberDef *ValueMemberDef_ptr;
-  typedef CORBA_ValueMemberDef_out ValueMemberDef_out;
-  typedef CORBA_ValueMemberDef_var ValueMemberDef_var;
-
-  typedef CORBA_ValueDescription ValueDescription;
-  typedef CORBA_ValueDescription *ValueDescription_ptr;
-  typedef CORBA_ValueDescription_out ValueDescription_out;
-  typedef CORBA_ValueDescription_var ValueDescription_var;
-
-  typedef CORBA_EnumMemberSeq EnumMemberSeq;
-  typedef CORBA_EnumMemberSeq *EnumMemberSeq_ptr;
-  typedef CORBA_EnumMemberSeq_out EnumMemberSeq_out;
-  typedef CORBA_EnumMemberSeq_var EnumMemberSeq_var;
+  typedef CORBA_TypeCodeFactory TypeCodeFactory;
+  typedef CORBA_TypeCodeFactory *TypeCodeFactory_ptr;
+  typedef CORBA_TypeCodeFactory_out TypeCodeFactory_out;
+  typedef CORBA_TypeCodeFactory_var TypeCodeFactory_var;
+
 #endif /* TAO_HAS_INTERFACE_REPOSITORY == 1 */
 
   typedef CORBA_Bounds Bounds;
@@ -1155,7 +688,7 @@ TAO_NAMESPACE CORBA
   TAO_NAMESPACE_INLINE_FUNCTION Boolean is_nil (Principal_ptr);
   TAO_NAMESPACE_INLINE_FUNCTION Boolean is_nil (ServerRequest_ptr req);
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if !defined (TAO_HAS_MINIMUM_CORBA)
 
   TAO_NAMESPACE_INLINE_FUNCTION Boolean is_nil (Request_ptr);
   TAO_NAMESPACE_INLINE_FUNCTION Boolean is_nil (NamedValue_ptr);
@@ -1172,7 +705,7 @@ TAO_NAMESPACE CORBA
   TAO_NAMESPACE_INLINE_FUNCTION void release (ORB_ptr);
   TAO_NAMESPACE_INLINE_FUNCTION void release (ServerRequest_ptr req);
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if !defined (TAO_HAS_MINIMUM_CORBA)
 
   TAO_NAMESPACE_INLINE_FUNCTION void release (Request_ptr);
   TAO_NAMESPACE_INLINE_FUNCTION void release (NamedValue_ptr);
@@ -1226,6 +759,8 @@ TAO_NAMESPACE CORBA
     tk_value_box          = 30,
     tk_native             = 31,
     tk_abstract_interface = 32,
+    tk_component          = 33, 
+    tk_home               = 34,
 
     // This symbol is not defined by CORBA 2.0.  It's used to speed up
     // dispatch based on TCKind values, and lets many important ones
@@ -1268,7 +803,7 @@ TAO_NAMESPACE CORBA
   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Bounds;
   TAO_NAMESPACE_STORAGE_CLASS TypeCode_ptr _tc_Current;
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if !defined (TAO_HAS_MINIMUM_CORBA)
   TAO_NAMESPACE_STORAGE_CLASS TypeCode_ptr _tc_NamedValue;
 #endif /* End of Minimum CORBA */
   enum
@@ -1402,7 +937,7 @@ TAO_NAMESPACE CORBA
 
   TAO_NAMESPACE_STORAGE_CLASS const PolicyType SecConstruction;
 
-#if (TAO_HAS_MINIMUM_CORBA == 0)
+#if ! defined (TAO_HAS_MINIMUM_CORBA)
   typedef CORBA_ConstructionPolicy ConstructionPolicy;
   typedef CORBA_ConstructionPolicy *ConstructionPolicy_ptr;
   typedef CORBA_ConstructionPolicy_var ConstructionPolicy_var;
@@ -1468,7 +1003,7 @@ TAO_NAMESPACE CORBA
   typedef CORBA::String_out Identifier_out;
   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Identifier;
 
-#ifdef TAO_HAS_INTERFACE_REPOSITORY
+#if (TAO_HAS_INTERFACE_REPOSITORY == 1)
   // ------------------------------Interface REPOS Bala
 
   // =================== Interface Repository =====================
@@ -1477,157 +1012,8 @@ TAO_NAMESPACE CORBA
   typedef CORBA_String_out ScopedName_out;
   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ScopedName;
 
-
-
-
-
-  enum DefinitionKind
-  {
-    dk_none,
-    dk_all,
-    dk_Attribute,
-    dk_Constant,
-    dk_Exception,
-    dk_Interface,
-    dk_Module,
-    dk_Operation,
-    dk_Typedef,
-    dk_Alias,
-    dk_Struct,
-    dk_Union,
-    dk_Enum,
-    dk_Primitive,
-    dk_String,
-    dk_Sequence,
-    dk_Array,
-    dk_Repository,
-    dk_Wstring,
-    dk_Fixed,
-    dk_Value,
-    dk_ValueBox,
-    dk_ValueMember,
-    dk_Native
-  };
-
-  typedef DefinitionKind &DefinitionKind_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_DefinitionKind;
-
   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IRObject;
-
-  typedef char * VersionSpec;
-  typedef CORBA_String_var VersionSpec_var;
-  typedef CORBA_String_out VersionSpec_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_VersionSpec;
-
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Container;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Contained;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDefSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDefSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContainedSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMember;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructMemberSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Initializer;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InitializerSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMember;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionMemberSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumMemberSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_IDLType;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_Repository;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ModuleDescription;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ConstantDescription;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypedefDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypeDescription;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StructDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_UnionDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_EnumDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AliasDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_StringDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_WstringDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_FixedDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_SequenceDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ArrayDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDescription;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeDescription;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterDescription;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParDescriptionSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExceptionDefSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ExcDescriptionSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationDescription;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_RepositoryIdSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OpDescriptionSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttrDescriptionSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_InterfaceDescription;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMember;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberSeq;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueMemberDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDef;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueDescription;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ValueBoxDef;
-
-  enum PrimitiveKind
-  {
-    pk_null,
-    pk_void,
-    pk_short,
-    pk_long,
-    pk_ushort,
-    pk_ulong,
-    pk_float,
-    pk_double,
-    pk_boolean,
-    pk_char,
-    pk_octet,
-    pk_any,
-    pk_TypeCode,
-    pk_Principal,
-    pk_string,
-    pk_objref,
-    pk_longlong,
-    pk_ulonglong,
-    pk_longdouble,
-    pk_wchar,
-    pk_wstring
-  };
-   typedef PrimitiveKind &PrimitiveKind_out;
-   TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_PrimitiveKind;
-
-   enum AttributeMode
-  {
-    ATTR_NORMAL,
-    ATTR_READONLY
-  };
-  typedef AttributeMode &AttributeMode_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_AttributeMode;
-
-  enum OperationMode
-  {
-    OP_NORMAL,
-    OP_ONEWAY
-  };
-  typedef OperationMode &OperationMode_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_OperationMode;
-
-  enum ParameterMode
-  {
-    PARAM_IN,
-    PARAM_OUT,
-    PARAM_INOUT
-  };
-  typedef ParameterMode &ParameterMode_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ParameterMode;
-
-  typedef char * ContextIdentifier;
-  typedef CORBA::String_var ContextIdentifier_var;
-  typedef CORBA::String_out ContextIdentifier_out;
-  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_ContextIdentifier;
+  TAO_NAMESPACE_STORAGE_CLASS CORBA::TypeCode_ptr _tc_TypeCodeFactory;
 
   typedef CORBA::Short Visibility;
   typedef CORBA::Short_out Visibility_out;
@@ -1646,7 +1032,7 @@ TAO_NAMESPACE CORBA
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short VM_ABSTRACT;
   TAO_NAMESPACE_STORAGE_CLASS const CORBA::Short VM_TRUNCATABLE;
   // ================== Interface Repository =====================
-#endif /*TAO_HAS_INTERFACE_REPOSITORY */
+#endif /* TAO_HAS_INTERFACE_REPOSITORY */
   // There could be a single version of these methods, but g++ 2.7.2
   // gets horribly confused if we used CORBA::default_environment() at
   // this point.